diff --git a/src/actions/upload.ts b/src/actions/upload.ts
index 06eb8e14..40b7fd39 100644
--- a/src/actions/upload.ts
+++ b/src/actions/upload.ts
@@ -5,7 +5,7 @@ import {catchError, mergeMap, mergeMapTo, switchMap} from 'rxjs/operators'
 import type {SanityClient} from 'sanity'
 
 import {createUpChunkObservable} from '../clients/upChunkObservable'
-import type {MuxAsset, PluginConfig, UploadConfig} from '../util/types'
+import type {MuxAsset, MuxNewAssetSettings, PluginConfig, UploadConfig} from '../util/types'
 import {getAsset} from './assets'
 import {testSecretsObservable} from './secrets'
 
@@ -19,11 +19,11 @@ export function cancelUpload(client: SanityClient, uuid: string) {
 
 export function uploadUrl({
   url,
-  uploadConfig,
+  settings,
   client,
 }: {
   url: string
-  uploadConfig: UploadConfig
+  settings: MuxNewAssetSettings
   client: SanityClient
 }) {
   return testUrl(url).pipe(
@@ -36,14 +36,11 @@ export function uploadUrl({
               return throwError(new Error('Invalid credentials'))
             }
             const uuid = generateUuid()
-            const muxBody = {
-              input: validUrl,
-              mp4_support: uploadConfig.mp4_support,
-              encoding_tier: uploadConfig.encoding_tier,
-              max_resolution_tier: uploadConfig.max_resolution_tier,
-              playback_policy: [uploadConfig.signed ? 'signed' : 'public'],
-              // @TODO: send tracks to backend
-            }
+            const muxBody = settings
+            if (!muxBody.input) muxBody.input = [{type: 'video'}]
+            muxBody.input[0].url = validUrl
+            console.log(muxBody)
+
             const query = {
               muxBody: JSON.stringify(muxBody),
               filename: validUrl.split('/').slice(-1)[0],
@@ -81,11 +78,11 @@ export function uploadUrl({
 }
 
 export function uploadFile({
-  uploadConfig,
+  settings,
   client,
   file,
 }: {
-  uploadConfig: UploadConfig
+  settings: MuxNewAssetSettings
   client: SanityClient
   file: File
 }) {
@@ -99,13 +96,7 @@ export function uploadFile({
               return throwError(new Error('Invalid credentials'))
             }
             const uuid = generateUuid()
-            const body = {
-              mp4_support: uploadConfig.mp4_support,
-              encoding_tier: uploadConfig.encoding_tier,
-              max_resolution_tier: uploadConfig.max_resolution_tier,
-              playback_policy: [uploadConfig.signed ? 'signed' : 'public'],
-              // @TODO: send tracks to backend
-            }
+            const body = settings
 
             return concat(
               of({type: 'uuid' as const, uuid}),
@@ -115,13 +106,7 @@ export function uploadFile({
                   upload: {
                     cors_origin: string
                     id: string
-                    new_asset_settings: Pick<
-                      Required<PluginConfig>,
-                      'mp4_support' | 'encoding_tier' | 'max_resolution_tier'
-                    > & {
-                      passthrough: string
-                      playback_policies: ['public' | 'signed']
-                    }
+                    new_asset_settings: MuxNewAssetSettings
                     status: 'waiting'
                     timeout: number
                     url: string
diff --git a/src/components/FileInputArea.tsx b/src/components/FileInputArea.tsx
new file mode 100644
index 00000000..f7c00f1f
--- /dev/null
+++ b/src/components/FileInputArea.tsx
@@ -0,0 +1,92 @@
+import {PropsWithChildren, useRef, useState} from 'react'
+import {Box, Button, Card, CardTone, Flex, Inline, Text} from '@sanity/ui'
+import {FileInputButton} from './FileInputButton'
+import {UploadIcon} from '@sanity/icons'
+import {extractDroppedFiles} from '../util/extractFiles'
+
+interface FileInputAreaProps extends PropsWithChildren {
+  accept?: string
+  acceptMIMETypes?: string[]
+  label: React.ReactNode
+  onSelect: (files: FileList | File[]) => void
+}
+
+export default function FileInputArea({
+  label,
+  accept,
+  acceptMIMETypes,
+  onSelect,
+}: FileInputAreaProps) {
+  const dragEnteredEls = useRef<EventTarget[]>([])
+  const [dragState, setDragState] = useState<'valid' | 'invalid' | null>(null)
+
+  // Stages and validates an upload from dragging+dropping files or folders
+  const handleDrop: React.DragEventHandler<HTMLDivElement> = (event) => {
+    setDragState(null)
+    event.preventDefault()
+    event.stopPropagation()
+    extractDroppedFiles(event.nativeEvent.dataTransfer!).then(onSelect)
+  }
+
+  /* ------------------------------- Drag State ------------------------------- */
+
+  const handleDragOver: React.DragEventHandler<HTMLDivElement> = (event) => {
+    event.preventDefault()
+    event.stopPropagation()
+  }
+
+  const handleDragEnter: React.DragEventHandler<HTMLDivElement> = (event) => {
+    event.stopPropagation()
+    dragEnteredEls.current.push(event.target)
+    const type = event.dataTransfer.items?.[0]?.type
+    setDragState(
+      !acceptMIMETypes || acceptMIMETypes.some((mimeType) => type?.match(mimeType))
+        ? 'valid'
+        : 'invalid'
+    )
+  }
+
+  const handleDragLeave: React.DragEventHandler<HTMLDivElement> = (event) => {
+    event.stopPropagation()
+    const idx = dragEnteredEls.current.indexOf(event.target)
+    if (idx > -1) {
+      dragEnteredEls.current.splice(idx, 1)
+    }
+    if (dragEnteredEls.current.length === 0) {
+      setDragState(null)
+    }
+  }
+
+  let tone: CardTone = 'inherit'
+  if (dragState) tone = dragState === 'valid' ? 'positive' : 'critical'
+  return (
+    <Card border sizing="border" tone={tone} style={{borderStyle: 'dashed'}} padding={3}>
+      <Flex
+        align="center"
+        justify="space-between"
+        gap={4}
+        direction={['column', 'column', 'row']}
+        paddingY={[2, 2, 0]}
+        sizing="border"
+        onDrop={handleDrop}
+        onDragOver={handleDragOver}
+        onDragLeave={handleDragLeave}
+        onDragEnter={handleDragEnter}
+      >
+        <Flex align="center" justify="center" gap={2} flex={1}>
+          {label}
+        </Flex>
+        <Inline space={2}>
+          <FileInputButton
+            mode="ghost"
+            tone="default"
+            icon={UploadIcon}
+            text="Upload"
+            onSelect={onSelect}
+            accept={accept}
+          />
+        </Inline>
+      </Flex>
+    </Card>
+  )
+}
diff --git a/src/components/FileInputButton.tsx b/src/components/FileInputButton.tsx
index a29c7ae5..618668f0 100644
--- a/src/components/FileInputButton.tsx
+++ b/src/components/FileInputButton.tsx
@@ -17,8 +17,9 @@ const Label = styled.label`
 
 export interface FileInputButtonProps extends ButtonProps {
   onSelect: (files: FileList) => void
+  accept?: string
 }
-export const FileInputButton = ({onSelect, ...props}: FileInputButtonProps) => {
+export const FileInputButton = ({onSelect, accept, ...props}: FileInputButtonProps) => {
   const inputId = `FileSelect${useId()}`
   const inputRef = useRef<HTMLInputElement>(null)
   const handleSelect = useCallback<React.ChangeEventHandler<HTMLInputElement>>(
@@ -33,7 +34,7 @@ export const FileInputButton = ({onSelect, ...props}: FileInputButtonProps) => {
   return (
     <Label htmlFor={inputId}>
       <HiddenInput
-        accept="video/*"
+        accept={accept || 'video/*'}
         ref={inputRef}
         tabIndex={0}
         type="file"
diff --git a/src/components/TextTracksEditor.tsx b/src/components/TextTracksEditor.tsx
index 27d93958..4494bf66 100644
--- a/src/components/TextTracksEditor.tsx
+++ b/src/components/TextTracksEditor.tsx
@@ -1,143 +1,161 @@
-import {AddIcon, ResetIcon, TranslateIcon, TrashIcon} from '@sanity/icons'
-import {
-  Autocomplete,
-  Button,
-  Card,
-  Checkbox,
-  Code,
-  Flex,
-  Radio,
-  Stack,
-  Text,
-  TextInput,
-  useToast,
-} from '@sanity/ui'
+import {AddIcon, DocumentTextIcon, ResetIcon, TranslateIcon, TrashIcon} from '@sanity/icons'
+import {Autocomplete, Button, Card, Code, Flex, Radio, Stack, Text, useToast} from '@sanity/ui'
 import LanguagesList from 'iso-639-1'
-import {useId} from 'react'
+import {Dispatch} from 'react'
 
 import {
-  AutogeneratedTextTrack,
   CustomTextTrack,
   SUPPORTED_MUX_LANGUAGES,
-  SUPPORTED_MUX_LANGUAGES_VALUES,
-  SupportedMuxLanguage,
   UploadTextTrack,
   isCustomTextTrack,
 } from '../util/types'
 import {FormField} from 'sanity'
+import FileInputArea from './FileInputArea'
+import {uuid} from '@sanity/uuid'
+
+/* -------------------------------- Constants ------------------------------- */
+
+const ALL_LANGUAGE_CODES = LanguagesList.getAllCodes().map((code) => ({
+  value: code,
+  label: LanguagesList.getNativeName(code),
+}))
 
-const LANGUAGES: Record<UploadTextTrack['type'], {value: string; label: string}[]> = {
+const SUBTITLE_LANGUAGES: Record<
+  Extract<UploadTextTrack, {language_code: any}>['type'],
+  {value: string; label: string}[]
+> = {
   autogenerated: SUPPORTED_MUX_LANGUAGES.map((lang) => ({
     value: lang.code,
     label: lang.label,
   })),
-  custom: LanguagesList.getAllCodes().map((code) => ({
-    value: code,
-    label: LanguagesList.getNativeName(code),
-  })),
+  subtitles: ALL_LANGUAGE_CODES,
+  captions: ALL_LANGUAGE_CODES,
 }
 
 const TRACK_TYPES = [
   {value: 'autogenerated', label: 'Auto-generated Subtitles'},
-  {value: 'custom', label: 'Custom'},
+  {value: 'subtitles', label: 'Subtitles'},
+  {value: 'captions', label: 'Closed Captions'},
 ] as const
 
+/* --------------------------------- Typings -------------------------------- */
+
+type TrackSubAction =
+  | {subAction: 'add'}
+  | {subAction: 'update'; value: Partial<UploadTextTrack>}
+  | {subAction: 'delete'}
+
+export type TrackAction = {action: 'track'; id: string} & TrackSubAction
+
+/**
+ * Handles editing of a single text track, dispatching actions back to the
+ * parent UploadConfiguration state object for changing internal state.
+ *
+ * @param param0
+ * @returns
+ */
 function TrackEditor({
+  canAutoGenerate,
   track,
-  modifyTrack,
-  deleteTrack,
+  dispatch,
 }: {
-  track: Partial<UploadTextTrack>
-  modifyTrack: (track: Partial<UploadTextTrack>) => void
-  deleteTrack: () => void
+  canAutoGenerate?: boolean
+  track: Partial<UploadTextTrack> & {_id: string}
+  dispatch: Dispatch<TrackAction>
 }) {
-  const id = useId()
+  const {_id: id, type} = track
   const toast = useToast()
-  const {type = 'autogenerated'} = track
+  const dispatchTrackAction = (args: TrackSubAction) => dispatch({action: 'track', id, ...args})
 
-  function handleTypeChange(event: React.ChangeEvent<HTMLInputElement>) {
-    const newType = event.currentTarget.value as typeof type
+  // function handleFileChange(e: React.ChangeEvent<HTMLInputElement>) {
+  //   const file = e.currentTarget.files?.[0]
+  //   if (!file) return
 
-    modifyTrack({type: newType})
-    if (
-      newType === 'autogenerated' &&
-      !SUPPORTED_MUX_LANGUAGES_VALUES.includes(track.language_code as SupportedMuxLanguage)
-    ) {
-      modifyTrack({language_code: undefined})
-    }
-  }
+  //   if (file.type !== 'text/vtt' && file.type !== 'text/srt') {
+  //     e.currentTarget.files = null
+  //     toast.push({
+  //       status: 'error',
+  //       title: 'Invalid file type',
+  //     })
+  //     return
+  //   }
 
-  function handleLanguageChange(newValue: string) {
-    if (type === 'autogenerated') {
-      modifyTrack({
-        language_code: newValue,
-      } as Partial<AutogeneratedTextTrack>)
-    } else {
-      modifyTrack({
-        language_code: newValue,
-        name: LanguagesList.getNativeName(newValue),
-        closed_captions: 'closed_captions' in track ? track.closed_captions : false,
-      } as Partial<CustomTextTrack>)
-    }
-  }
-
-  function handleFileChange(e: React.ChangeEvent<HTMLInputElement>) {
-    const file = e.currentTarget.files?.[0]
-    if (!file) return
-
-    if (file.type !== 'text/vtt' && file.type !== 'text/srt') {
-      e.currentTarget.files = null
-      toast.push({
-        status: 'error',
-        title: 'Invalid file type',
-      })
-      return
-    }
-
-    fileToTrackFile(file)
-      .then((trackFile) => {
-        modifyTrack({
-          file: trackFile,
-        })
-      })
-      .catch(() => {
-        toast.push({
-          status: 'error',
-          title: 'Failed processing file',
-        })
-      })
-  }
+  //   fileToTrackFile(file)
+  //     .then((trackFile) => {
+  //       modifyTrack({
+  //         file: trackFile,
+  //       })
+  //     })
+  //     .catch(() => {
+  //       toast.push({
+  //         status: 'error',
+  //         title: 'Failed processing file',
+  //       })
+  //     })
+  // }
 
   return (
     <Card border padding={3} radius={2} as="form" style={{position: 'relative'}}>
       <Stack space={3}>
-        <FormField title="Text Track Type" description="">
+        <FormField
+          title="Track Type"
+          description={
+            <>
+              Specify whether this track contains{' '}
+              <a
+                href="https://www.ai-media.tv/knowledge-hub/insights/closed-captions-vs-subtitles"
+                target="_blank"
+                rel="noopener noreferrer"
+              >
+                Subtitles or Closed Captions
+              </a>
+              .
+            </>
+          }
+        >
           <Flex gap={3}>
-            {TRACK_TYPES.map(({value, label}) => {
-              const inputId = `${id}--type-${value}`
-              return (
-                <Flex key={value} align="center" gap={2}>
-                  <Radio
-                    checked={type === value}
-                    name="track-type"
-                    onChange={handleTypeChange}
-                    value={value}
-                    id={inputId}
-                  />
-                  <Text as="label" htmlFor={inputId}>
-                    {label}
-                  </Text>
-                </Flex>
-              )
-            })}
+            {TRACK_TYPES.filter(({value}) => !(value === 'autogenerated' && !canAutoGenerate)).map(
+              ({value, label}) => {
+                const inputId = `${id}--type-${value}`
+                return (
+                  <Flex key={value} align="center" gap={2}>
+                    <Radio
+                      checked={type === value}
+                      name="track-type"
+                      onChange={(e) =>
+                        dispatchTrackAction({
+                          subAction: 'update',
+                          value: {
+                            type: e.currentTarget.value as UploadTextTrack['type'],
+                          },
+                        })
+                      }
+                      value={value}
+                      id={inputId}
+                    />
+                    <Text as="label" htmlFor={inputId}>
+                      {label}
+                    </Text>
+                  </Flex>
+                )
+              }
+            )}
           </Flex>
         </FormField>
 
         <Autocomplete
           id={`${id}--language`}
           value={track.language_code}
-          onChange={handleLanguageChange}
-          options={LANGUAGES[type]}
+          onChange={(newValue) =>
+            dispatchTrackAction({
+              subAction: 'update',
+              value: {
+                language_code: newValue,
+                name: LanguagesList.getNativeName(newValue),
+              },
+            })
+          }
+          options={SUBTITLE_LANGUAGES[track.type!]}
           icon={TranslateIcon}
           placeholder="Select language"
           filterOption={(query, option) =>
@@ -145,7 +163,9 @@ function TrackEditor({
             option.value.toLowerCase().indexOf(query.toLowerCase()) > -1
           }
           openButton
-          renderValue={(value) => LANGUAGES[type].find((l) => l.value === value)?.label || value}
+          renderValue={(value) =>
+            SUBTITLE_LANGUAGES[track.type!].find((l) => l.value === value)?.label || value
+          }
           renderOption={(option) => (
             <Card data-as="button" padding={3} radius={2} tone="inherit">
               <Text size={2} textOverflow="ellipsis">
@@ -155,75 +175,64 @@ function TrackEditor({
           )}
         />
 
-        {isCustomTextTrack(track) && (
-          <>
-            {track.file ? (
-              <div style={{position: 'relative'}}>
-                <Card
-                  tone="transparent"
-                  paddingX={3}
-                  paddingY={4}
-                  border
-                  radius={1}
-                  style={{
-                    maxHeight: '250px',
-                    overflowY: 'auto',
-                  }}
-                >
-                  <Code>{track.file?.contents}</Code>
-                </Card>
-                <Button
-                  icon={ResetIcon}
-                  mode="bleed"
-                  style={{position: 'absolute', top: '1em', right: '1em'}}
-                  text="Replace"
-                  tone="critical"
-                  onClick={() => {
-                    modifyTrack({
-                      file: undefined,
-                    })
-                  }}
-                />
-              </div>
-            ) : (
-              <Stack as="label" space={1}>
-                <Text>Subtitles file (.vtt or .srt)</Text>
-                <TextInput
-                  name="file"
-                  type={'file' as any}
-                  required
-                  onChange={handleFileChange}
-                  accept=".vtt,.srt"
-                />
-              </Stack>
-            )}
-
-            <Flex align="center" gap={2}>
-              <Checkbox
-                id={`${id}--closed-captions`}
-                style={{display: 'block'}}
-                name="closed-captions"
-                required
-                checked={(track as CustomTextTrack).closed_captions || false}
-                onChange={(e) => {
-                  modifyTrack({
-                    closed_captions: e.currentTarget.checked,
+        {isCustomTextTrack(track) &&
+          (track.file ? (
+            <div style={{position: 'relative'}}>
+              <Card
+                tone="transparent"
+                paddingX={3}
+                paddingY={4}
+                border
+                radius={1}
+                style={{
+                  maxHeight: '250px',
+                  overflowY: 'auto',
+                }}
+              >
+                <Code>{track.file?.contents}</Code>
+              </Card>
+              <Button
+                icon={ResetIcon}
+                mode="bleed"
+                style={{position: 'absolute', top: '1em', right: '1em'}}
+                text="Replace"
+                tone="critical"
+                onClick={() => {
+                  dispatchTrackAction({
+                    subAction: 'update',
+                    value: {file: undefined},
                   })
                 }}
               />
-              <Text>
-                <label htmlFor={`${id}--closed-captions`}>Closed captions</label>
-              </Text>
-            </Flex>
-          </>
-        )}
+            </div>
+          ) : (
+            <FileInputArea
+              accept=".vtt, .srt"
+              acceptMIMETypes={['text/vtt', 'text/srt']}
+              label={
+                <>
+                  <Flex justify="center">
+                    <Text muted>
+                      <DocumentTextIcon />
+                    </Text>
+                  </Flex>
+                  <Flex justify="center">
+                    <Text size={1} muted>
+                      Drag or select subtitles file (.vtt, .srt)
+                    </Text>
+                  </Flex>
+                </>
+              }
+              onSelect={() => {}}
+            />
+          ))}
 
         <Flex>
           <Button
             icon={TrashIcon}
             tone="critical"
             mode="ghost"
-            onClick={deleteTrack}
+            onClick={() => dispatchTrackAction({subAction: 'delete'})}
             text="Delete"
           />
         </Flex>
@@ -233,55 +242,34 @@ function TrackEditor({
 }
 
 export default function TextTracksEditor({
+  canAutoGenerate,
   tracks,
-  setTracks,
+  dispatch,
 }: {
-  tracks: Partial<UploadTextTrack>[]
-  setTracks: (newTracks: Partial<UploadTextTrack>[]) => void
+  canAutoGenerate?: boolean
+  tracks: (Partial<UploadTextTrack> & {_id: string})[]
+  dispatch: Dispatch<TrackAction>
 }) {
-  function modifyTrack(index: number) {
-    return (newValues: Partial<UploadTextTrack>) => {
-      setTracks(
-        tracks.map((track, i) => {
-          if (i === index) {
-            return {
-              ...track,
-              ...newValues,
-            } as Partial<UploadTextTrack>
-          }
-          return track
-        }) || [newValues]
-      )
-    }
-  }
-
-  function deleteTrack(index: number) {
-    return () => {
-      setTracks((tracks || []).filter((_, i) => i !== index))
-    }
-  }
-
-  function addNewTrack() {
-    setTracks([
-      ...(tracks || []),
-      {
-        type: 'autogenerated',
-      },
-    ])
-  }
-
   return (
-    <FormField title="Captions & Subtitles" description="Provide text tracks for the video">
+    <FormField
+      title="Captions & Subtitles"
+      description="Provide text tracks for video accessibility."
+    >
       <Stack space={2}>
-        {tracks.map((track, index) => (
+        {tracks.map((track) => (
           <TrackEditor
-            key={index}
+            key={track._id}
+            canAutoGenerate={canAutoGenerate}
             track={track}
-            modifyTrack={modifyTrack(index)}
-            deleteTrack={deleteTrack(index)}
+            dispatch={dispatch}
           />
         ))}
-        <Button icon={AddIcon} onClick={addNewTrack} text="New caption/subtitle" mode="ghost" />
+        <Button
+          icon={AddIcon}
+          onClick={() => dispatch({action: 'track', id: uuid(), subAction: 'add'})}
+          text="New caption/subtitle"
+          mode="ghost"
+        />
       </Stack>
     </FormField>
   )
diff --git a/src/components/UploadConfiguration.tsx b/src/components/UploadConfiguration.tsx
index 4cc37c37..755fd677 100644
--- a/src/components/UploadConfiguration.tsx
+++ b/src/components/UploadConfiguration.tsx
@@ -1,47 +1,157 @@
-import {UploadIcon} from '@sanity/icons'
-import {Button, Card, Checkbox, Code, Dialog, Flex, Radio, Stack, Text} from '@sanity/ui'
-import {useEffect, useId, useRef, useState} from 'react'
+import {DocumentVideoIcon, UploadIcon} from '@sanity/icons'
+import {Button, Card, Checkbox, Dialog, Flex, Label, Radio, Stack, Text} from '@sanity/ui'
+import {useEffect, useId, useReducer, useRef} from 'react'
+import LanguagesList from 'iso-639-1'
 
-import {PluginConfig, Secrets, UploadConfig} from '../util/types'
-import TextTracksEditor from './TextTracksEditor'
+import {
+  AutogeneratedTextTrack,
+  CustomTextTrack,
+  MuxNewAssetSettings,
+  PluginConfig,
+  Secrets,
+  SupportedMuxLanguage,
+  UploadConfig,
+  UploadTextTrack,
+  isAutogeneratedTrack,
+  isCustomTextTrack,
+} from '../util/types'
+import TextTracksEditor, {TrackAction} from './TextTracksEditor'
 import {FormField} from 'sanity'
+import {StagedUpload} from './Uploader'
+import formatBytes from '../util/formatBytes'
+import {uuid} from '@sanity/uuid'
 
-const UPLOAD_DEFAULTS: UploadConfig = {
-  encoding_tier: 'smart',
-  max_resolution_tier: '1080p',
-  mp4_support: 'none',
-  signed: false,
-  text_tracks: [],
-}
+export type UploadConfigurationStateAction =
+  | {action: 'encoding_tier'; value: UploadConfig['encoding_tier']}
+  | {action: 'max_resolution_tier'; value: UploadConfig['max_resolution_tier']}
+  | {action: 'mp4_support'; value: UploadConfig['mp4_support']}
+  | {action: 'normalize_audio'; value: UploadConfig['normalize_audio']}
+  | {action: 'signed'; value: UploadConfig['signed']}
+  | TrackAction
+
+const ENCODING_OPTIONS = [
+  {value: 'smart', label: 'Smart'},
+  {value: 'baseline', label: 'Baseline'},
+] as const satisfies {value: UploadConfig['encoding_tier']; label: string}[]
+
+const RESOLUTION_TIERS = [
+  {value: '1080p', label: '1080p'},
+  {value: '1440p', label: '1440p (2k)'},
+  {value: '2160p', label: '2160p (4k)'},
+] as const satisfies {value: UploadConfig['max_resolution_tier']; label: string}[]
 
+/**
+ * The modal for configuring a staged upload. Handles triggering of the asset
+ * upload, even if no modal needs to be shown.
+ *
+ * @returns
+ */
 export default function UploadConfiguration({
+  stagedUpload,
   secrets,
-  disableConfig,
   pluginConfig,
-  schemaConfig,
   startUpload,
   onClose,
 }: {
+  stagedUpload: StagedUpload
   secrets: Secrets
-  disableConfig?: boolean
   pluginConfig: PluginConfig
-  schemaConfig?: PluginConfig
-  startUpload: (uploadConfig: UploadConfig) => void
+  startUpload: (settings: MuxNewAssetSettings) => void
   onClose: () => void
 }) {
   const id = useId()
-  const mergedConfig = useRef(Object.assign({}, pluginConfig, schemaConfig)).current
-  const [config, setConfig] = useState<UploadConfig>(
-    Object.assign({...UPLOAD_DEFAULTS}, mergedConfig)
+  const autoTextTracks = useRef<NonNullable<UploadConfig['text_tracks']>>(
+    (pluginConfig.encoding_tier === 'smart' &&
+      pluginConfig.defaultAutogeneratedSubtitleLangs?.map(
+        (language_code) =>
+          ({
+            _id: uuid(),
+            type: 'autogenerated',
+            language_code,
+            name: LanguagesList.getNativeName(language_code),
+          }) satisfies AutogeneratedTextTrack
+      )) ||
+      []
+  ).current
+
+  const [config, dispatch] = useReducer(
+    (prev: UploadConfig, action: UploadConfigurationStateAction) => {
+      switch (action.action) {
+        case 'encoding_tier':
+          // If encoding tier switches to baseline, remove smart-only features
+          if (action.value === 'baseline') {
+            return Object.assign({}, prev, {
+              encoding_tier: action.value,
+              mp4_support: 'none',
+              max_resolution_tier: '1080p',
+              text_tracks: prev.text_tracks?.filter(({type}) => type !== 'autogenerated'),
+            })
+            // If encoding tier switches to smart, add back in default smart features
+          } else {
+            return Object.assign({}, prev, {
+              encoding_tier: action.value,
+              mp4_support: pluginConfig.mp4_support,
+              max_resolution_tier: pluginConfig.max_resolution_tier,
+              text_tracks: [...autoTextTracks, ...(prev.text_tracks || [])],
+            })
+          }
+        case 'mp4_support':
+        case 'max_resolution_tier':
+        case 'normalize_audio':
+        case 'signed':
+          return Object.assign({}, prev, {[action.action]: action.value})
+        // Updating individual tracks
+        case 'track': {
+          const text_tracks = [...prev.text_tracks]
+          const target_track_i = text_tracks.findIndex(({_id}) => _id === action.id)
+          switch (action.subAction) {
+            case 'add':
+              // Exit early if track already exists
+              if (target_track_i !== -1) break
+              text_tracks.push(
+                (prev.encoding_tier === 'smart'
+                  ? {_id: action.id, type: 'autogenerated'}
+                  : {_id: action.id, type: 'subtitles'}) as UploadTextTrack
+              )
+              break
+            case 'update':
+              if (target_track_i === -1) break
+              text_tracks[target_track_i] = {
+                ...text_tracks[target_track_i],
+                ...action.value,
+              } as UploadTextTrack
+              break
+            case 'delete':
+              if (target_track_i === -1) break
+              text_tracks.splice(target_track_i, 1)
+              break
+          }
+          return Object.assign({}, prev, {text_tracks})
+        }
+        default:
+          return prev
+      }
+    },
+    {
+      encoding_tier: pluginConfig.encoding_tier,
+      max_resolution_tier: pluginConfig.max_resolution_tier,
+      mp4_support: pluginConfig.mp4_support,
+      signed: secrets.enableSignedUrls && pluginConfig.defaultSigned,
+      normalize_audio: pluginConfig.normalize_audio,
+      text_tracks: autoTextTracks,
+    } as UploadConfig
   )
 
   // If user-provided config is disabled, begin the upload immediately with
   // the developer-specified values from the schema or config or defaults.
+  // This can include auto-generated subtitles!
+  const {disableTextTrackConfig, disableUploadConfig} = pluginConfig
+  const skipConfig = disableTextTrackConfig && disableUploadConfig
   useEffect(() => {
-    if (disableConfig) startUpload(config)
+    if (skipConfig) startUpload(formatUploadConfig(config))
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
-  if (disableConfig) return null
+  if (skipConfig) return null
 
   return (
     <Dialog
@@ -49,152 +159,225 @@ export default function UploadConfiguration({
       id="upload-configuration"
       zOffset={1000}
       width={1}
-      header="Configure upload"
+      header="Configure Mux Upload"
       onClose={onClose}
     >
-      <Card paddingX={3} paddingY={4}>
-        <Stack space={4}>
-          {secrets.enableSignedUrls && (
-            <Flex align="center" gap={2}>
-              <Checkbox
-                id={`${id}--signed`}
-                style={{display: 'block'}}
-                name="signed"
-                required
-                checked={config.signed}
-                onChange={(e) => {
-                  setConfig({
-                    ...config,
-                    signed: e.currentTarget.checked,
-                  })
-                }}
-              />
-              <Text>
-                <label htmlFor={`${id}--signed`}>Signed playback URL</label>
+      <Stack padding={4} space={2}>
+        <Label size={3}>FILE TO UPLOAD</Label>
+        <Card
+          tone="transparent"
+          border
+          padding={3}
+          paddingY={4}
+          style={{borderRadius: '0.1865rem'}}
+        >
+          <Flex gap={2}>
+            <DocumentVideoIcon fontSize="2em" />
+            <Stack space={2}>
+              <Text textOverflow="ellipsis" as="h2" size={3}>
+                {stagedUpload.type === 'file' ? stagedUpload.files[0].name : stagedUpload.url}
               </Text>
-            </Flex>
-          )}
-
-          <Flex align="center" gap={2}>
-            <Checkbox
-              id={`${id}--encoding_tier`}
-              style={{display: 'block'}}
-              name="encoding_tier"
-              required
-              checked={config.encoding_tier === 'smart'}
-              onChange={(e) => {
-                setConfig({
-                  ...config,
-                  encoding_tier: e.currentTarget.checked ? 'smart' : 'baseline',
-                })
-              }}
-            />
-            <Text>
-              <label htmlFor={`${id}--encoding_tier`}>Smart encoding</label>
-            </Text>
+              <Text as="p" size={1} muted>
+                {stagedUpload.type === 'file'
+                  ? `Direct File Upload (${formatBytes(stagedUpload.files[0].size)})`
+                  : 'File From URL (Unknown size)'}
+              </Text>
+            </Stack>
           </Flex>
+        </Card>
+        {!disableUploadConfig && (
+          <Stack space={3} paddingBottom={2}>
+            <FormField
+              title="Encoding Tier"
+              description={
+                <>
+                  The encoding tier informs the cost, quality, and available platform features for
+                  the asset.{' '}
+                  <a
+                    href="https://docs.mux.com/guides/use-encoding-tiers"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                  >
+                    See the Mux guide for more details.
+                  </a>
+                </>
+              }
+            >
+              <Flex gap={3}>
+                {ENCODING_OPTIONS.map(({value, label}) => {
+                  const inputId = `${id}--encodingtier-${value}`
+                  return (
+                    <Flex key={value} align="center" gap={2}>
+                      <Radio
+                        checked={config.encoding_tier === value}
+                        name="asset-encodingtier"
+                        onChange={(e) =>
+                          dispatch({
+                            action: 'encoding_tier' as const,
+                            value: e.currentTarget.value as UploadConfig['encoding_tier'],
+                          })
+                        }
+                        value={value}
+                        id={inputId}
+                      />
+                      <Text as="label" htmlFor={inputId}>
+                        {label}
+                      </Text>
+                    </Flex>
+                  )
+                })}
+              </Flex>
+            </FormField>
 
-          {config.encoding_tier === 'smart' && mergedConfig.mp4_support !== 'none' && (
-            <Flex align="center" gap={2}>
-              <Checkbox
-                id={`${id}--mp4_support`}
-                style={{display: 'block'}}
-                name="mp4_support"
-                required
-                checked={config.mp4_support === 'standard'}
-                onChange={(e) => {
-                  setConfig({
-                    ...config,
-                    mp4_support: e.currentTarget.checked ? 'standard' : 'none',
-                  })
-                }}
-              />
-              <Text>
-                <label htmlFor={`${id}--mp4_support`}>MP4 support (allow downloading)</label>
-              </Text>
-            </Flex>
-          )}
+            {config.encoding_tier === 'smart' && (
+              <FormField
+                title="Resolution Tier"
+                description={
+                  <>
+                    The maximum{' '}
+                    <a
+                      href="https://docs.mux.com/api-reference#video/operation/create-direct-upload"
+                      target="_blank"
+                      rel="noopener noreferrer"
+                    >
+                      resolution_tier
+                    </a>{' '}
+                    your asset is encoded, stored, and streamed at.
+                  </>
+                }
+              >
+                <Flex gap={3} wrap={'wrap'}>
+                  {RESOLUTION_TIERS.map(({value, label}) => {
+                    const inputId = `${id}--type-${value}`
+                    return (
+                      <Flex key={value} align="center" gap={2}>
+                        <Radio
+                          checked={config.max_resolution_tier === value}
+                          name="asset-resolutiontier"
+                          onChange={(e) =>
+                            dispatch({
+                              action: 'max_resolution_tier',
+                              value: e.currentTarget.value as UploadConfig['max_resolution_tier'],
+                            })
+                          }
+                          value={value}
+                          id={inputId}
+                        />
+                        <Text as="label" htmlFor={inputId}>
+                          {label}
+                        </Text>
+                      </Flex>
+                    )
+                  })}
+                </Flex>
+              </FormField>
+            )}
 
-          <FormField
-            title="Resolution Tier"
-            description={
-              <>
-                The maximum{' '}
-                <code>
-                  <a href="https://docs.mux.com/api-reference#video/operation/create-direct-upload">
-                    resolution_tier
-                  </a>
-                </code>{' '}
-                your asset is encoded, stored, and streamed at.
-              </>
-            }
-          >
-            <Flex gap={3}>
-              {getResolutionOptions(config, mergedConfig).map(({value, label, disabled}) => {
-                const inputId = `${id}--type-${value}`
-                return (
-                  <Flex key={value} align="center" gap={2} disabled={disabled}>
-                    <Radio
-                      checked={config.max_resolution_tier === value}
-                      name="track-type"
-                      onChange={(e) => {
-                        setConfig({
-                          ...config,
-                          max_resolution_tier: e.currentTarget
-                            .value as UploadConfig['max_resolution_tier'],
-                        })
-                      }}
-                      value={value}
-                      id={inputId}
-                      disabled={disabled}
-                    />
-                    <Text as="label" htmlFor={inputId}>
-                      {label}
-                    </Text>
-                  </Flex>
-                )
-              })}
-            </Flex>
-          </FormField>
+            {(secrets.enableSignedUrls || config.encoding_tier === 'smart') && (
+              <FormField title="Additional Configuration">
+                <Stack space={2}>
+                  {secrets.enableSignedUrls && (
+                    <Flex align="center" gap={2}>
+                      <Checkbox
+                        id={`${id}--signed`}
+                        style={{display: 'block'}}
+                        name="signed"
+                        required
+                        checked={config.signed}
+                        onChange={(e) =>
+                          dispatch({
+                            action: 'signed',
+                            value: e.currentTarget.checked,
+                          })
+                        }
+                      />
+                      <Text>
+                        <label htmlFor={`${id}--signed`}>Signed playback URL</label>
+                      </Text>
+                    </Flex>
+                  )}
+                  {config.encoding_tier === 'smart' && (
+                    <Flex align="center" gap={2}>
+                      <Checkbox
+                        id={`${id}--mp4_support`}
+                        style={{display: 'block'}}
+                        name="mp4_support"
+                        required
+                        checked={config.mp4_support === 'standard'}
+                        onChange={(e) =>
+                          dispatch({
+                            action: 'mp4_support',
+                            value: e.currentTarget.checked ? 'standard' : 'none',
+                          })
+                        }
+                      />
+                      <Text>
+                        <label htmlFor={`${id}--mp4_support`}>
+                          MP4 support (allow downloading)
+                        </label>
+                      </Text>
+                    </Flex>
+                  )}
+                </Stack>
+              </FormField>
+            )}
+          </Stack>
+        )}
 
+        {!disableTextTrackConfig && (
           <TextTracksEditor
-            tracks={config.text_tracks || []}
-            setTracks={(newTracks) => {
-              setConfig({
-                ...config,
-                text_tracks: newTracks as UploadConfig['text_tracks'],
-              })
-            }}
+            canAutoGenerate={config.encoding_tier === 'smart'}
+            tracks={config.text_tracks}
+            dispatch={dispatch}
           />
+        )}
 
-          <Button
-            icon={UploadIcon}
-            text="Upload"
-            tone="positive"
-            onClick={() => startUpload(config)}
-          />
-        </Stack>
-      </Card>
+        <Button
+          icon={UploadIcon}
+          text="Upload"
+          tone="positive"
+          onClick={() => startUpload(formatUploadConfig(config))}
+        />
+      </Stack>
     </Dialog>
   )
 }
 
-function getResolutionOptions({encoding_tier}: UploadConfig, {max_resolution_tier}: PluginConfig) {
-  return [
-    {value: '1080p', label: '1080p', disabled: false},
-    {
-      value: '1440p',
-      label: '1440p (2k)',
-      disabled: !(encoding_tier === 'smart' && max_resolution_tier !== '1080p'),
-    },
-    {
-      value: '2160p',
-      label: '2160p (4k)',
-      disabled: !(
-        encoding_tier === 'smart' &&
-        max_resolution_tier !== '1080p' &&
-        max_resolution_tier !== '1440p'
+function formatUploadConfig(config: UploadConfig): MuxNewAssetSettings {
+  const generated_subtitles = config.text_tracks
+    .filter<AutogeneratedTextTrack>(isAutogeneratedTrack)
+    .map<{name: string; language_code: SupportedMuxLanguage}>((track) => ({
+      name: track.name,
+      language_code: track.language_code,
+    }))
+
+  return {
+    input: [
+      {
+        type: 'video',
+        generated_subtitles: generated_subtitles.length > 0 ? generated_subtitles : undefined,
+      },
+      ...config.text_tracks.filter<CustomTextTrack>(isCustomTextTrack).reduce(
+        (acc, track) => {
+          if (track.language_code && track.file && track.name) {
+            acc.push({
+              url: track.file.contents,
+              type: 'text',
+              text_type: track.type === 'subtitles' ? 'subtitles' : undefined,
+              language_code: track.language_code,
+              name: track.name,
+              closed_captions: track.type === 'captions',
+            })
+          }
+          return acc
+        },
+        [] as NonNullable<MuxNewAssetSettings['input']>
       ),
-    },
-  ]
+    ],
+    mp4_support: config.mp4_support,
+    playback_policy: config.signed ? ['public', 'signed'] : ['public'],
+    max_resolution_tier: config.max_resolution_tier,
+    encoding_tier: config.encoding_tier,
+    normalize_audio: config.normalize_audio,
+  }
 }
diff --git a/src/components/Uploader.tsx b/src/components/Uploader.tsx
index c72464ef..2968f875 100644
--- a/src/components/Uploader.tsx
+++ b/src/components/Uploader.tsx
@@ -12,6 +12,7 @@ import {isValidUrl} from '../util/asserters'
 import {extractDroppedFiles} from '../util/extractFiles'
 import type {
   MuxInputProps,
+  MuxNewAssetSettings,
   PluginConfig,
   Secrets,
   UploadConfig,
@@ -25,7 +26,7 @@ import {UploadCard} from './Uploader.styled'
 import UploadPlaceholder from './UploadPlaceholder'
 import {UploadProgress} from './UploadProgress'
 
-interface Props extends Pick<MuxInputProps, 'onChange' | 'readOnly' | 'schemaType'> {
+interface Props extends Pick<MuxInputProps, 'onChange' | 'readOnly'> {
   config: PluginConfig
   client: SanityClient
   secrets: Secrets
@@ -35,14 +36,17 @@ interface Props extends Pick<MuxInputProps, 'onChange' | 'readOnly' | 'schemaTyp
   needsSetup: boolean
 }
 
+export type StagedUpload = {type: 'file'; files: FileList | File[]} | {type: 'url'; url: string}
+type UploadStatus = {
+  progress: number
+  file?: {name: string | undefined; type: string}
+  uuid?: string
+  url?: string
+}
+
 interface State {
-  stagedUpload: {type: 'file'; files: FileList | File[]} | {type: 'url'; url: string} | null
-  uploadStatus: {
-    progress: number
-    file?: {name: string | undefined; type: string}
-    uuid?: string
-    url?: string
-  } | null
+  stagedUpload: StagedUpload | null
+  uploadStatus: UploadStatus | null
   error: Error | null
 }
 
@@ -65,6 +69,14 @@ type UploaderStateAction =
   | {action: 'error'; error: any}
   | {action: 'complete' | 'reset'}
 
+/**
+ * The main interface for inputting a Mux Video. It handles staging an upload
+ * file, setting its configuration, displaying upload progress, and showing
+ * the preview player.
+ *
+ * @param props
+ * @returns
+ */
 export default function Uploader(props: Props) {
   const toast = useToast()
   const containerRef = useRef<HTMLDivElement>(null)
@@ -148,10 +160,10 @@ export default function Uploader(props: Props) {
    * Should only be called from the UploadConfiguration component, which provides
    * the Mux configuration for the direct asset upload.
    *
-   * @param uploadConfig
+   * @param settings The Mux new_asset_settings object to send to Sanity
    * @returns
    */
-  const startUpload = (uploadConfig: UploadConfig) => {
+  const startUpload = (settings: MuxNewAssetSettings) => {
     const {stagedUpload} = state
     if (!stagedUpload || uploadRef.current) return
     dispatch({action: 'commitUpload'})
@@ -162,14 +174,14 @@ export default function Uploader(props: Props) {
         uploadObservable = uploadUrl({
           client: props.client,
           url: stagedUpload.url,
-          uploadConfig,
+          settings,
         })
         break
       case 'file':
         uploadObservable = uploadFile({
           client: props.client,
           file: stagedUpload.files[0],
-          uploadConfig,
+          settings,
         }).pipe(
           takeUntil(
             cancelUploadButton.observable.pipe(
@@ -220,7 +232,10 @@ export default function Uploader(props: Props) {
 
   // Stages an upload from the file selector
   const handleUpload = (files: FileList | File[]) => {
-    dispatch({action: 'stageUpload', input: {type: 'file', files}})
+    dispatch({
+      action: 'stageUpload',
+      input: {type: 'file', files},
+    })
   }
 
   // Stages and validates an upload from pasting an asset URL
@@ -242,7 +257,10 @@ export default function Uploader(props: Props) {
     event.preventDefault()
     event.stopPropagation()
     extractDroppedFiles(event.nativeEvent.dataTransfer!).then((files) => {
-      dispatch({action: 'stageUpload', input: {type: 'file', files}})
+      dispatch({
+        action: 'stageUpload',
+        input: {type: 'file', files},
+      })
     })
   }
 
@@ -307,8 +325,8 @@ export default function Uploader(props: Props) {
   if (state.stagedUpload !== null) {
     return (
       <UploadConfiguration
+        stagedUpload={state.stagedUpload}
         pluginConfig={props.config}
-        schemaConfig={props.schemaType.options}
         secrets={props.secrets}
         startUpload={startUpload}
         onClose={() => dispatch({action: 'reset'})}
diff --git a/src/index.ts b/src/index.ts
index fcb43976..7e9ced6b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -10,6 +10,7 @@ export const defaultConfig: PluginConfig = {
   mp4_support: 'none',
   encoding_tier: 'smart',
   max_resolution_tier: '1080p',
+  normalize_audio: false,
   defaultSigned: false,
   tool: DEFAULT_TOOL_CONFIG,
 }
diff --git a/src/plugin.tsx b/src/plugin.tsx
index 85198599..83c64add 100644
--- a/src/plugin.tsx
+++ b/src/plugin.tsx
@@ -7,7 +7,9 @@ import type {PluginConfig, MuxInputProps, VideoAssetDocument} from './util/types
 export function muxVideoCustomRendering(config: PluginConfig) {
   return {
     components: {
-      input: (props: MuxInputProps) => <Input config={config} {...props} />,
+      input: (props: MuxInputProps) => (
+        <Input config={{...config, ...props.schemaType.options}} {...props} />
+      ),
     },
     preview: {
       select: {
diff --git a/src/util/formatBytes.ts b/src/util/formatBytes.ts
new file mode 100644
index 00000000..2a60fcbd
--- /dev/null
+++ b/src/util/formatBytes.ts
@@ -0,0 +1,32 @@
+/* eslint-disable */
+// From: https://stackoverflow.com/questions/10420352/converting-file-size-in-bytes-to-human-readable-string
+/**
+ * Format bytes as human-readable text.
+ *
+ * @param bytes Number of bytes.
+ * @param si True to use metric (SI) units, aka powers of 1000. False to use
+ *           binary (IEC), aka powers of 1024.
+ * @param dp Number of decimal places to display.
+ *
+ * @return Formatted string.
+ */
+export default function formatBytes(bytes: number, si = false, dp = 1) {
+  const thresh = si ? 1000 : 1024
+
+  if (Math.abs(bytes) < thresh) {
+    return bytes + ' B'
+  }
+
+  const units = si
+    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']
+  let u = -1
+  const r = 10 ** dp
+
+  do {
+    bytes /= thresh
+    ++u
+  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1)
+
+  return bytes.toFixed(dp) + ' ' + units[u]
+}
diff --git a/src/util/types.ts b/src/util/types.ts
index 5c6cc3bf..04350784 100644
--- a/src/util/types.ts
+++ b/src/util/types.ts
@@ -8,36 +8,73 @@ import type {
 } from 'sanity'
 import type {PartialDeep} from 'type-fest'
 
-export interface PluginConfig {
+export interface MuxInputConfig {
   /**
    * Enable static renditions by setting this to 'standard'. Can be overwritten on a per-asset basis.
+   * Requires `"encoding_tier": "smart"`
    * @see {@link https://docs.mux.com/guides/video/enable-static-mp4-renditions#why-enable-mp4-support}
    * @defaultValue 'none'
    */
-  mp4_support: 'none' | 'standard'
+  mp4_support: MuxNewAssetSettings['mp4_support']
 
   /**
    * Max resolution tier can be used to control the maximum resolution_tier your asset is encoded, stored, and streamed at.
+   * Requires `"encoding_tier": "smart"`
    * @see {@link https://docs.mux.com/guides/stream-videos-in-4k}
    * @defaultValue '1080p'
    */
-  max_resolution_tier: '2160p' | '1440p' | '1080p'
+  max_resolution_tier: MuxNewAssetSettings['max_resolution_tier']
 
   /**
    * The encoding tier informs the cost, quality, and available platform features for the asset.
    * @see {@link https://docs.mux.com/guides/use-encoding-tiers}
    * @defaultValue 'smart'
    */
-  encoding_tier: 'baseline' | 'smart'
+  encoding_tier: MuxNewAssetSettings['encoding_tier']
+
+  /**
+   * Normalize the audio track loudness level.
+   * @see {@link https://docs.mux.com/guides/adjust-audio-levels#how-to-turn-on-audio-normalization}
+   * @defaultValue false
+   */
+  normalize_audio: MuxNewAssetSettings['normalize_audio']
+
+  /**
+   * Enables signed URLs by default, if you configured them with your API token.
+   * @see {@link https://docs.mux.com/guides/secure-video-playback}
+   * @defaultValue false
+   */
+  defaultSigned?: boolean
+
+  /**
+   * Auto-generate captions for these languages by default.
+   * Requires `"encoding_tier": "smart"`
+   *
+   * @see {@link https://docs.mux.com/guides/secure-video-playback}
+   * @defaultValue false
+   */
+  defaultAutogeneratedSubtitleLangs?: SupportedMuxLanguage[]
+
+  /**
+   * Whether or not to allow content editors to override asset upload
+   * configuration settings when uploading a video to Mux.
+   *
+   * @see {@link https://docs.mux.com/guides/secure-video-playback}
+   * @defaultValue false
+   */
+  disableUploadConfig?: boolean
 
   /**
-   * Whether or not to use signed URLs by default, making assets private.
-   * Can still be overwritten on a per-asset basis.
+   * Whether or not to allow content editors to add text tracks alongside their
+   * asset when uploading a video to Mux.
+   *
    * @see {@link https://docs.mux.com/guides/secure-video-playback}
    * @defaultValue false
    */
-  defaultSigned: boolean
+  disableTextTrackConfig?: boolean
+}
 
+export interface PluginConfig extends MuxInputConfig {
   /**
    * How the videos browser should appear as a studio tool in Sanity's top navigation
    *
@@ -81,17 +118,19 @@ export const SUPPORTED_MUX_LANGUAGES_VALUES = SUPPORTED_MUX_LANGUAGES.map((l) =>
 
 export type SupportedMuxLanguage = (typeof SUPPORTED_MUX_LANGUAGES_VALUES)[number]
 
-export type AutogeneratedTextTrack = {
+export interface TextTrack {
+  _id: string
+  name: string
+}
+
+export interface AutogeneratedTextTrack extends TextTrack {
   type: 'autogenerated'
   language_code: SupportedMuxLanguage
-  isSourceLanguage: boolean
 }
 
-export type CustomTextTrack = {
-  type: 'custom'
-  name: string
+export interface CustomTextTrack extends TextTrack {
+  type: 'subtitles' | 'captions'
   language_code: string
-  closed_captions: boolean
   file: {
     contents: string
     type: string
@@ -100,18 +139,72 @@ export type CustomTextTrack = {
   }
 }
 
-export function isCustomTextTrack(
+export function isCustomTextTrack(track: Partial<UploadTextTrack>): track is CustomTextTrack {
+  return track.type !== 'autogenerated'
+}
+
+export function isAutogeneratedTrack(
   track: Partial<UploadTextTrack>
-): track is Partial<CustomTextTrack> {
-  return track.type === 'custom'
+): track is AutogeneratedTextTrack {
+  return track.type === 'autogenerated'
 }
 
 export type UploadTextTrack = AutogeneratedTextTrack | CustomTextTrack
 
 export interface UploadConfig
-  extends Pick<PluginConfig, 'encoding_tier' | 'max_resolution_tier' | 'mp4_support'> {
-  text_tracks?: UploadTextTrack[]
-  signed?: boolean
+  extends Pick<
+    MuxInputConfig,
+    'encoding_tier' | 'max_resolution_tier' | 'mp4_support' | 'normalize_audio'
+  > {
+  text_tracks: UploadTextTrack[]
+  signed: boolean
+}
+
+// Typings lifted from https://docs.mux.com/api-reference#video/operation/create-direct-upload
+export interface MuxNewAssetSettings {
+  /** An array of objects that each describe an input file to be used to create the asset.*/
+  input?: {
+    /** The URL of the file that Mux should download and use. */
+    url?: string
+    /** Generate subtitle tracks using automatic speech recognition with this configuration. This may only be provided for the first input object (the main input file).  */
+    generated_subtitles?: {
+      /** A name for this subtitle track. */
+      name: string
+      /** Arbitrary metadata set for the subtitle track. Max 255 characters. */
+      passthrough?: string
+      /** The language to generate subtitles in. */
+      language_code: SupportedMuxLanguage
+    }[]
+    /** The time offset in seconds from the beginning of the video indicating the clip's starting marker. */
+    start_time?: number
+    /** The time offset in seconds from the beginning of the video indicating the clip's ending marker. */
+    end_time?: number
+    /** This parameter is required for text type tracks. */
+    type: 'video' | 'audio' | 'text'
+    /** Type of text track. This parameter only supports subtitles value. */
+    text_type?: 'subtitles'
+    /** The language code value must be a valid BCP 47 specification compliant value. */
+    language_code?: string
+    /** The name of the track containing a human-readable description. This value must be unique within each group of text or audio track types. */
+    name?: string
+    /** Indicates the track provides Subtitles for the Deaf or Hard-of-hearing (SDH). */
+    closed_captions?: boolean
+    /// @TODO Huhh?>?? Below
+    /** This optional parameter should be used tracks with type of text and text_type set to subtitles. */
+    passthrough?: string
+  }[]
+  /** An array of playback policy names that you want applied to this asset and available through playback_ids. */
+  playback_policy: ('public' | 'signed')[]
+  /** Arbitrary user-supplied metadata that will be included in the asset details and related webhooks.  */
+  passthrough?: string
+  /** Specify what level (if any) of support for mp4 playback. */
+  mp4_support: 'none' | 'standard'
+  /** Normalize the audio track loudness level. */
+  normalize_audio: boolean
+  /** Max resolution tier can be used to control the maximum resolution_tier your asset is encoded, stored, and streamed at. If not set, this defaults to 1080p. */
+  max_resolution_tier: '1080p' | '1440p' | '2160p'
+  /** The encoding tier informs the cost, quality, and available platform features for the asset. By default the smart encoding tier is used. */
+  encoding_tier: 'smart' | 'baseline'
 }
 
 export interface Secrets {