AVAssetExportSession

allExportPresets

static allExportPresets(): Array<string>

class func allExportPresets() -> [String]

determineCompatibility

static determineCompatibility(presetName: string, asset: AVAsset, outputFileType: (AVFileType) | null, handler: ((arg0: boolean) => void)): void

class func compatibility(ofExportPreset presetName: String, with asset: AVAsset, outputFileType: AVFileType?) async -> Bool

exportPresets

static exportPresets(asset: AVAsset): Array<string>

class func exportPresets(compatibleWith asset: AVAsset) -> [String]

cancelExport

cancelExport(): void

func cancelExport()

determineCompatibleFileTypes

determineCompatibleFileTypes(handler: ((arg0: Array<AVFileType>) => void)): void

var compatibleFileTypes: [AVFileType] { get async }

estimateMaximumDuration

estimateMaximumDuration(handler: ((arg0: _CoreMedia_CMTime, arg1: (NativeError) | null) => void)): void

var estimatedMaximumDuration: CMTime { get async throws }

estimateOutputFileLength

estimateOutputFileLength(handler: ((arg0: number, arg1: (NativeError) | null) => void)): void

var estimatedOutputFileLengthInBytes: Int64 { get async throws }

exportAsynchronously

exportAsynchronously(handler: (() => void)): void

func export() async

init

static init(asset: AVAsset, presetName: string): (AVAssetExportSession) | null

init?(asset: AVAsset, presetName: String)

asset

get asset(): AVAsset

var asset: AVAsset { get }

audioMix

get audioMix(): (AVAudioMix) | null

@NSCopying var audioMix: AVAudioMix? { get set }

audioMix

set audioMix(value: (AVAudioMix) | null)

@NSCopying var audioMix: AVAudioMix? { get set }

audioTimePitchAlgorithm

get audioTimePitchAlgorithm(): AVAudioTimePitchAlgorithm

var audioTimePitchAlgorithm: AVAudioTimePitchAlgorithm { get set }

audioTimePitchAlgorithm

set audioTimePitchAlgorithm(value: AVAudioTimePitchAlgorithm)

var audioTimePitchAlgorithm: AVAudioTimePitchAlgorithm { get set }

audioTrackGroupHandling

get audioTrackGroupHandling(): AVAssetTrackGroupOutputHandling

var audioTrackGroupHandling: AVAssetTrackGroupOutputHandling { get set }

audioTrackGroupHandling

set audioTrackGroupHandling(value: AVAssetTrackGroupOutputHandling)

var audioTrackGroupHandling: AVAssetTrackGroupOutputHandling { get set }

canPerformMultiplePassesOverSourceMediaData

get canPerformMultiplePassesOverSourceMediaData(): boolean

var canPerformMultiplePassesOverSourceMediaData: Bool { get set }

canPerformMultiplePassesOverSourceMediaData

set canPerformMultiplePassesOverSourceMediaData(value: boolean)

var canPerformMultiplePassesOverSourceMediaData: Bool { get set }

customVideoCompositor

get customVideoCompositor(): (SDKHandle) | null

var customVideoCompositor: (any AVVideoCompositing)? { get }

directoryForTemporaryFiles

get directoryForTemporaryFiles(): (string) | null

var directoryForTemporaryFiles: URL? { get set }

directoryForTemporaryFiles

set directoryForTemporaryFiles(value: (string) | null)

var directoryForTemporaryFiles: URL? { get set }

error

get error(): (NativeError) | null

var error: (any Error)? { get }

estimatedOutputFileLength

get estimatedOutputFileLength(): number

var estimatedOutputFileLength: Int64 { get }

fileLengthLimit

get fileLengthLimit(): number

var fileLengthLimit: Int64 { get set }

fileLengthLimit

set fileLengthLimit(value: number)

var fileLengthLimit: Int64 { get set }

maxDuration

get maxDuration(): _CoreMedia_CMTime

var maxDuration: CMTime { get }

metadata

get metadata(): (Array<AVMetadataItem>) | null

var metadata: [AVMetadataItem]? { get set }

metadata

set metadata(value: (Array<AVMetadataItem>) | null)

var metadata: [AVMetadataItem]? { get set }

metadataItemFilter

get metadataItemFilter(): (AVMetadataItemFilter) | null

var metadataItemFilter: AVMetadataItemFilter? { get set }

metadataItemFilter

set metadataItemFilter(value: (AVMetadataItemFilter) | null)

var metadataItemFilter: AVMetadataItemFilter? { get set }

outputFileType

get outputFileType(): (AVFileType) | null

var outputFileType: AVFileType? { get set }

outputFileType

set outputFileType(value: (AVFileType) | null)

var outputFileType: AVFileType? { get set }

outputURL

get outputURL(): (string) | null

var outputURL: URL? { get set }

outputURL

set outputURL(value: (string) | null)

var outputURL: URL? { get set }

presetName

get presetName(): string

var presetName: String { get }

progress

get progress(): number

var progress: Float { get }

shouldOptimizeForNetworkUse

get shouldOptimizeForNetworkUse(): boolean

var shouldOptimizeForNetworkUse: Bool { get set }

shouldOptimizeForNetworkUse

set shouldOptimizeForNetworkUse(value: boolean)

var shouldOptimizeForNetworkUse: Bool { get set }

status

get status(): AVAssetExportSession_Status

var status: AVAssetExportSession.Status { get }

supportedFileTypes

get supportedFileTypes(): Array<AVFileType>

var supportedFileTypes: [AVFileType] { get }

timeRange

get timeRange(): _CoreMedia_CMTimeRange

var timeRange: CMTimeRange { get set }

timeRange

set timeRange(value: _CoreMedia_CMTimeRange)

var timeRange: CMTimeRange { get set }

videoComposition

get videoComposition(): (AVVideoComposition) | null

@NSCopying var videoComposition: AVVideoComposition? { get set }

videoComposition

set videoComposition(value: (AVVideoComposition) | null)

@NSCopying var videoComposition: AVVideoComposition? { get set }

configureForResumableExport

configureForResumableExport(): Promise<AVAssetExportSession_ResumptionState>

func configureForResumableExport() async -> AVAssetExportSession.ResumptionState

Configures the export session for resumable export. This method validates that the export session's current configuration supports resumption and checks the temporary directory for any partial results from previous export attempts. Call this method after configuring all export settings (preset, output file type, etc.) and before calling `exportAsynchronously()`. - Returns: A `ResumptionState` indicating whether resumption is available and whether the export will resume from a previous state. - Note: Even if resumption is not available, you can still perform a normal (non-resumable) export by calling `exportAsynchronously()`. Example usage: ```swift let exportSession = AVAssetExportSession(asset: asset, presetName: .hevc1920x1080)! exportSession.outputFileType = .mov exportSession.outputURL = outputURL exportSession.directoryForTemporaryFiles = temporaryDirectory let state = await exportSession.configureForResumableExport() switch state { case .resumable(let isResuming): print("Export is resumable. Continuing from previous state: \(isResuming)") case .notResumable(let reason): print("Cannot perform resumable export with current configuration: \(reason)") } try await exportSession.export(to: outputURL, as: .mov) ```

export

export(url: string, fileType: AVFileType): Promise<void>

@backDeployed(before: macOS 26.0, iOS 26.0, tvOS 26.0, visionOS 26.0)
final func export(to url: URL, as fileType: AVFileType, isolation: isolated (any Actor)? = #isolation) async throws

Initiates an asset export operation. Progress can be monitored using states(updateInterval:). Thrown errors may include: - CancellationError: export operation is cancelled - Parameters: - url: Indicates the URL of the export session's output. You may use UTType.preferredFilenameExtension to obtain an appropriate path extension for the fileType you have specified. For more information, see <UniformTypeIdentifiers/UTType.h> - fileType: Indicates the type of file to be written by the session.

states

states(updateInterval?: number): (SDKHandle) & (SDKHandle)

func states(updateInterval: TimeInterval = .infinity) -> some Sendable & AsyncSequence<AVAssetExportSession.State, Never>

Monitor the progress of an asset export session - Parameter updateInterval: time interval between updates while in exporting state - Returns: sequence of asset export session progress states