objcjs-types 0.1.0 → 0.2.1

package/dist/AVFoundation/AVCapturePhotoOutput.d.ts

@@ -4,6 +4,7 @@ import type { _AVCapturePhotoCaptureDelegate } from "./AVCapturePhotoCaptureDele
 import type { _AVCapturePhotoSettings } from "./AVCapturePhotoSettings.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { CMVideoDimensions } from "../structs/CMVideoDimensions.js";
 import type { AVCapturePhotoOutputCaptureReadiness } from "./AVCapturePhotoOutputCaptureReadiness.js";
 import type { AVCapturePhotoQualityPrioritization } from "./AVCapturePhotoQualityPrioritization.js";
@@ -13,21 +14,21 @@ export declare class _AVCapturePhotoOutput extends _AVCaptureOutput {
     /**
      * @method isBayerRAWPixelFormat: @abstract Returns YES if the given pixel format is a Bayer RAW format. @discussion May be used to distinguish Bayer RAW from Apple ProRAW pixel formats in -availableRawPhotoPixelFormatTypes once appleProRAWEnabled has been set to YES.
      */
-    static isBayerRAWPixelFormat$(pixelFormat: NobjcObject): boolean;
+    static isBayerRAWPixelFormat$(pixelFormat: number): boolean;
     /**
      * @method isAppleProRAWPixelFormat: @abstract Returns YES if the given pixel format is an Apple ProRAW format. @discussion May be used to distinguish Bayer RAW from Apple ProRAW pixel formats in -availableRawPhotoPixelFormatTypes once appleProRAWEnabled has been set to YES. See appleProRAWEnabled for more information on Apple ProRAW.
      */
-    static isAppleProRAWPixelFormat$(pixelFormat: NobjcObject): boolean;
+    static isAppleProRAWPixelFormat$(pixelFormat: number): boolean;
     /**
      * @method JPEGPhotoDataRepresentationForJPEGSampleBuffer:previewPhotoSampleBuffer: @abstract A class method that writes a JPEG sample buffer to an NSData in the JPEG file format. @param JPEGSampleBuffer A CMSampleBuffer containing JPEG compressed data. @param previewPhotoSampleBuffer An optional CMSampleBuffer containing pixel buffer image data to be written as a thumbnail image. @result An NSData containing bits in the JPEG file format. May return nil if the re-packaging process fails. @discussion AVCapturePhotoOutput's depecrated -captureOutput:didFinishProcessingPhotoSampleBuffer:previewPhotoSampleBuffer:resolvedSettings:bracketSettings:error: callback delivers JPEG photos to clients as CMSampleBuffers. To re-package these buffers in a data format suitable for writing to a JPEG file, you may call this class method, optionally inserting your own metadata into the JPEG CMSampleBuffer first, and optionally passing a preview image to be written to the JPEG file format as a thumbnail image.
      * @deprecated -[AVCapturePhoto fileDataRepresentation]
      */
-    static JPEGPhotoDataRepresentationForJPEGSampleBuffer$previewPhotoSampleBuffer$(JPEGSampleBuffer: NobjcObject, previewPhotoSampleBuffer: NobjcObject): _NSData | null;
+    static JPEGPhotoDataRepresentationForJPEGSampleBuffer$previewPhotoSampleBuffer$(JPEGSampleBuffer: NobjcObject, previewPhotoSampleBuffer: NobjcObject | null): _NSData | null;
     /**
      * @method DNGPhotoDataRepresentationForRawSampleBuffer:previewPhotoSampleBuffer: @abstract A class method that writes a RAW sample buffer to an NSData containing bits in the DNG file format. @param rawSampleBuffer A CMSampleBuffer containing Bayer RAW data. @param previewPhotoSampleBuffer An optional CMSampleBuffer containing pixel buffer image data to be written as a thumbnail image. @result An NSData containing bits in the DNG file format. May return nil if the re-packaging process fails. @discussion AVCapturePhotoOutput's deprecated -captureOutput:didFinishProcessingRawPhotoSampleBuffer:previewPhotoSampleBuffer:resolvedSettings:bracketSettings:error: callback delivers RAW photos to clients as CMSampleBuffers. To re-package these buffers in a data format suitable for writing to a DNG file, you may call this class method, optionally inserting your own metadata into the RAW CMSampleBuffer first, and optionally passing a preview image to be written to the DNG file format as a thumbnail image. Only RAW images from Apple built-in cameras are supported.
      * @deprecated -[AVCapturePhoto fileDataRepresentation]
      */
-    static DNGPhotoDataRepresentationForRawSampleBuffer$previewPhotoSampleBuffer$(rawSampleBuffer: NobjcObject, previewPhotoSampleBuffer: NobjcObject): _NSData | null;
+    static DNGPhotoDataRepresentationForRawSampleBuffer$previewPhotoSampleBuffer$(rawSampleBuffer: NobjcObject, previewPhotoSampleBuffer: NobjcObject | null): _NSData | null;
     init(): _AVCapturePhotoOutput;
     /**
      * @method capturePhotoWithSettings:delegate: @abstract Method for initiating a photo capture request with progress monitoring through the supplied delegate. @param settings An AVCapturePhotoSettings object you have configured. May not be nil. @param delegate An object conforming to the AVCapturePhotoCaptureDelegate protocol. This object's delegate methods are called back as the photo advances from capture to processing to finished delivery. May not be nil. @discussion This method initiates a photo capture. The receiver copies your provided settings to prevent unintentional mutation. It is illegal to re-use settings. The receiver throws an NSInvalidArgumentException if your settings.uniqueID matches that of any previously used settings. This method is used to initiate all flavors of photo capture: single photo, RAW capture with or without a processed image (such as a JPEG), bracketed capture, and Live Photo. Clients need not wait for a capture photo request to complete before issuing another request. This is true for single photo captures as well as Live Photos, where movie complements of adjacent photo captures are allowed to overlap. This method validates your settings and enforces the following rules in order to ensure deterministic behavior. If any of these rules are violated, a NSInvalidArgumentException is thrown. RAW rules: See +isBayerRAWPixelFormat: and +isAppleProRAWPixelFormat: on the difference between Bayer RAW and Apple ProRAW pixel formats. Common RAW rules: - If rawPhotoPixelFormatType is non-zero, it must be present in the receiver's -availableRawPhotoPixelFormatTypes array. - If rawPhotoPixelFormatType is non-zero, your delegate must respond to -captureOutput:didFinishProcessingRawPhotoSampleBuffer:previewPhotoSampleBuffer:resolvedSettings:bracketSettings:error:. - If rawPhotoPixelFormatType is non-zero, highResolutionPhotoEnabled may be YES or NO, but the setting only applies to the processed image, if you've specified one. - If rawPhotoPixelFormatType is non-zero, constantColorEnabled must be set to NO. - If rawFileType is specified, it must be present in -availableRawPhotoFileTypes and must support the rawPhotoPixelFormatType specified using -supportedRawPhotoPixelFormatTypesForFileType:. Bayer RAW rules (isBayerRAWPixelFormat: returns yes for rawPhotoPixelFormatType): - photoQualityPrioritization must be set to AVCapturePhotoQualityPrioritizationSpeed (deprecated autoStillImageStabilizationEnabled must be set to NO). - the videoZoomFactor of the source device and the videoScaleAndCropFactor of the photo output's video connection must both be 1.0. Ensure no zoom is applied before requesting a RAW capture, and don't change the zoom during RAW capture. Apple ProRAW rules (isAppleProRAWPixelFormat: returns yes for rawPhotoPixelFormatType): - livePhotoMovieFileURL must be nil in AVCapturePhotoSettings settings - autoContentAwareDistortionCorrectionEnabled will automatically be disabled in AVCapturePhotoSettings - autoRedEyeReductionEnabled will automatically be disabled in AVCapturePhotoSettings - portraitEffectsMatteDeliveryEnabled will automatically be disabled in AVCapturePhotoSettings - enabledSemanticSegmentationMatteTypes will automatically be cleared in AVCapturePhotoSettings Processed Format rules: - If format is non-nil, a kCVPixelBufferPixelFormatTypeKey or AVVideoCodecKey must be present. You cannot specify both. - If format has a kCVPixelBufferPixelFormatTypeKey, its value must be present in the receiver's -availablePhotoPixelFormatTypes array. - If format has an AVVideoCodecKey, its value must be present in the receiver's -availablePhotoCodecTypes array. - If format is non-nil, your delegate must respond to -captureOutput:didFinishProcessingPhotoSampleBuffer:previewPhotoSampleBuffer:resolvedSettings:bracketSettings:error:. - If processedFileType is specified, it must be present in -availablePhotoFileTypes and must support the format's specified kCVPixelBufferPixelFormatTypeKey (using -supportedPhotoPixelFormatTypesForFileType:) or AVVideoCodecKey (using -supportedPhotoCodecTypesForFileType:). - The photoQualityPrioritization you specify may not be a greater number than the photo output's maxPhotoQualityPrioritization. You must set your AVCapturePhotoOutput maxPhotoQualityPrioritization up front. Flash rules: - The specified flashMode must be present in the receiver's -supportedFlashModes array. Live Photo rules: - The receiver's livePhotoCaptureEnabled must be YES if settings.livePhotoMovieURL is non-nil. - If settings.livePhotoMovieURL is non-nil, the receiver's livePhotoCaptureSuspended property must be set to NO. - If settings.livePhotoMovieURL is non-nil, it must be a file URL that's accessible to your app's sandbox. - If settings.livePhotoMovieURL is non-nil, your delegate must respond to -captureOutput:didFinishProcessingLivePhotoToMovieFileAtURL:duration:photoDisplayTime:resolvedSettings:error:. Bracketed capture rules: - bracketedSettings.count must be <= the receiver's maxBracketedCapturePhotoCount property. - For manual exposure brackets, ISO value must be within the source device activeFormat's minISO and maxISO values. - For manual exposure brackets, exposureDuration value must be within the source device activeFormat's minExposureDuration and maxExposureDuration values. - For auto exposure brackets, exposureTargetBias value must be within the source device's minExposureTargetBias and maxExposureTargetBias values. Deferred Photo Delivery rules: - If the receiver's autoDeferredPhotoDeliveryEnabled is YES, your delegate must respond to -captureOutput:didFinishCapturingDeferredPhotoProxy:error:. - The maxPhotoDimensions setting for 24MP (5712, 4284), when supported, is only serviced as 24MP via deferred photo delivery. Color space rules: - Photo capture is not supported when AVCaptureDevice has selected AVCaptureColorSpace_AppleLog or AVCaptureColorSpace_AppleLog2 as color space.
@@ -36,23 +37,23 @@ export declare class _AVCapturePhotoOutput extends _AVCaptureOutput {
     /**
      * @method setPreparedPhotoSettingsArray:completionHandler: @abstract Method allowing the receiver to prepare resources in advance for future -capturePhotoWithSettings:delegate: requests. @param preparedPhotoSettingsArray An array of AVCapturePhotoSettings instances indicating the types of capture for which the receiver should prepare resources. @param completionHandler A completion block to be fired on a serial dispatch queue once the receiver has finished preparing. You may pass nil to indicate you do not wish to be called back when preparation is complete. @discussion Some types of photo capture, such as bracketed captures and RAW captures, require the receiver to allocate additional buffers or prepare other resources. To prevent photo capture requests from executing slowly due to lazy resource allocation, you may call this method with an array of settings objects representative of the types of capture you will be performing (e.g., settings for a bracketed capture, RAW capture, and/or still image stabilization capture). You may call this method even before calling -[AVCaptureSession startRunning] in order to hint the receiver up front which features you'll be utilizing. Each time you call this method with an array of settings, the receiver evaluates what additional resources it needs to allocate, as well as existing resources that can be reclaimed, and calls back your completionHandler when it has finished preparing (and possibly reclaiming) needed resources. By default, the receiver prepares sufficient resources to capture photos with default settings, +[AVCapturePhotoSettings photoSettings]. If you wish to reclaim all possible resources, you may call this method with an empty array. Preparation for photo capture is always optional. You may call -capturePhotoWithSettings:delegate: without first calling -setPreparedPhotoSettingsArray:completionHandler:, but be advised that some of your photo captures may execute slowly as additional resources are allocated just-in-time. If you call this method while your AVCaptureSession is not running, your completionHandler does not fire immediately. It only fires once you've called -[AVCaptureSession startRunning], and the needed resources have actually been prepared. If you call -setPreparedPhotoSettingsArray:completionHandler: with an array of settings, and then call it a second time, your first prepare call's completionHandler fires immediately with prepared == NO. Prepared settings persist across session starts/stops and committed configuration changes. This property participates in -[AVCaptureSession beginConfiguration] / -[AVCaptureSession commitConfiguration] deferred work behavior. That is, if you call -[AVCaptureSession beginConfiguration], change your session's input/output topology, and call this method, preparation is deferred until you call -[AVCaptureSession commitConfiguration], enabling you to atomically commit a new configuration as well as prepare to take photos in that new configuration.
      */
-    setPreparedPhotoSettingsArray$completionHandler$(preparedPhotoSettingsArray: _NSArray, completionHandler: NobjcObject): void;
+    setPreparedPhotoSettingsArray$completionHandler$(preparedPhotoSettingsArray: _NSArray, completionHandler: NobjcObject | null): void;
     /**
      * @method supportedPhotoPixelFormatTypesForFileType: @abstract An array of pixel format type values that are currently supported by the receiver for a particular file container. @param fileType The AVFileType container type intended for storage of a photo. @result An array of CVPixelBufferPixelFormatTypeKey values supported by the receiver for the file type in question. @discussion If you wish to capture a photo for storage in a particular file container, such as TIFF, you must ensure that the photo pixel format type you request is valid for that file type. If no pixel format types are supported for a given fileType, an empty array is returned. If you've not yet added your receiver to an AVCaptureSession with a video source, no pixel format types are supported.
      */
-    supportedPhotoPixelFormatTypesForFileType$(fileType: number): _NSArray;
+    supportedPhotoPixelFormatTypesForFileType$(fileType: _NSString): _NSArray;
     /**
      * @method supportedPhotoCodecTypesForFileType: @abstract An array of AVVideoCodecKey values that are currently supported by the receiver for a particular file container. @param fileType The AVFileType container type intended for storage of a photo. @result An array of AVVideoCodecKey values supported by the receiver for the file type in question. @discussion If you wish to capture a photo for storage in a particular file container, such as HEIF, you must ensure that the photo codec type you request is valid for that file type. If no codec types are supported for a given fileType, an empty array is returned. If you've not yet added your receiver to an AVCaptureSession with a video source, no codec types are supported.
      */
-    supportedPhotoCodecTypesForFileType$(fileType: number): _NSArray;
+    supportedPhotoCodecTypesForFileType$(fileType: _NSString): _NSArray;
     /**
      * @method supportedRawPhotoCodecTypesForRawPhotoPixelFormatType:fileType: @abstract An array of AVVideoCodecType values that are currently supported by the receiver for a particular file container and raw pixel format. @param pixelFormatType A Bayer RAW or Apple ProRAW pixel format OSType (defined in CVPixelBuffer.h). @param fileType The AVFileType container type intended for storage of a photo which can be retrieved from -availableRawPhotoFileTypes. @result An array of AVVideoCodecType values supported by the receiver for the file type and and raw pixel format in question. @discussion If you wish to capture a raw photo for storage using a Bayer RAW or Apple ProRAW pixel format and to be stored in a file container, such as DNG, you must ensure that the codec type you request is valid for that file and pixel format type. If no RAW codec types are supported for a given file type and/or pixel format type, an empty array is returned. If you have not yet added your receiver to an AVCaptureSession with a video source, an empty array is returned.
      */
-    supportedRawPhotoCodecTypesForRawPhotoPixelFormatType$fileType$(pixelFormatType: NobjcObject, fileType: number): _NSArray;
+    supportedRawPhotoCodecTypesForRawPhotoPixelFormatType$fileType$(pixelFormatType: number, fileType: _NSString): _NSArray;
     /**
      * @method supportedRawPhotoPixelFormatTypesForFileType: @abstract An array of CVPixelBufferPixelFormatType values that are currently supported by the receiver for a particular file container. @param fileType The AVFileType container type intended for storage of a photo. @result An array of CVPixelBufferPixelFormatType values supported by the receiver for the file type in question. @discussion If you wish to capture a photo for storage in a particular file container, such as DNG, you must ensure that the RAW pixel format type you request is valid for that file type. If no RAW pixel format types are supported for a given fileType, an empty array is returned. If you've not yet added your receiver to an AVCaptureSession with a video source, no pixel format types are supported.
      */
-    supportedRawPhotoPixelFormatTypesForFileType$(fileType: number): _NSArray;
+    supportedRawPhotoPixelFormatTypesForFileType$(fileType: _NSString): _NSArray;
     /**
      * @property preparedPhotoSettingsArray @abstract An array of AVCapturePhotoSettings instances for which the receiver is prepared to capture. @discussion See also setPreparedPhotoSettingsArray:completionHandler: Some types of photo capture, such as bracketed captures and RAW captures, require the receiver to allocate additional buffers or prepare other resources. To prevent photo capture requests from executing slowly due to lazy resource allocation, you may call -setPreparedPhotoSettingsArray:completionHandler: with an array of settings objects representative of the types of capture you will be performing (e.g., settings for a bracketed capture, RAW capture, and/or still image stabilization capture). By default, the receiver prepares sufficient resources to capture photos with default settings, +[AVCapturePhotoSettings photoSettings].
      */

package/dist/AVFoundation/AVCapturePhotoSettings.d.ts

@@ -1,7 +1,8 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { CMVideoDimensions } from "../structs/CMVideoDimensions.js";
 import type { AVCaptureFlashMode } from "./AVCaptureFlashMode.js";
@@ -22,15 +23,15 @@ export declare class _AVCapturePhotoSettings extends _NSObject {
     /**
      * @method photoSettingsWithRawPixelFormatType: @abstract Creates an instance of AVCapturePhotoSettings specifying RAW only output. @param rawPixelFormatType A Bayer RAW or Apple ProRAW pixel format OSType (defined in CVPixelBuffer.h). @result An instance of AVCapturePhotoSettings. @discussion rawPixelFormatType must be one of the OSTypes contained in AVCapturePhotoOutput's -availableRawPhotoPixelFormatTypes array. See AVCapturePhotoOutput's -capturePhotoWithSettings:delegate: inline documentation for a discussion of restrictions on AVCapturePhotoSettings when requesting RAW capture.
      */
-    static photoSettingsWithRawPixelFormatType$(rawPixelFormatType: NobjcObject): _AVCapturePhotoSettings;
+    static photoSettingsWithRawPixelFormatType$(rawPixelFormatType: number): _AVCapturePhotoSettings;
     /**
      * @method photoSettingsWithRawPixelFormatType:processedFormat: @abstract Creates an instance of AVCapturePhotoSettings specifying RAW + a processed format (such as JPEG). @param rawPixelFormatType A Bayer RAW or Apple ProRAW pixel format OSType (defined in CVPixelBuffer.h). @param processedFormat A dictionary of Core Video pixel buffer attributes or AVVideoSettings, analogous to AVCaptureStillImageOutput's outputSettings property. @result An instance of AVCapturePhotoSettings. @discussion rawPixelFormatType must be one of the OSTypes contained in AVCapturePhotoOutput's -availableRawPhotoPixelFormatTypes array. If you wish an uncompressed processedFormat, your dictionary must contain kCVPixelBufferPixelFormatTypeKey, and the processedFormat specified must be present in AVCapturePhotoOutput's -availablePhotoPixelFormatTypes array. kCVPixelBufferPixelFormatTypeKey is the only supported key when expressing uncompressed processedFormat. If you wish a compressed format, your dictionary must contain AVVideoCodecKey and the codec specified must be present in AVCapturePhotoOutput's -availablePhotoCodecTypes array. If you are specifying a compressed format, the AVVideoCompressionPropertiesKey is also supported, with a payload dictionary containing a single AVVideoQualityKey. Passing a nil processedFormat dictionary is analogous to calling +photoSettingsWithRawPixelFormatType:. See AVCapturePhotoOutput's -capturePhotoWithSettings:delegate: inline documentation for a discussion of restrictions on AVCapturePhotoSettings when requesting RAW capture.
      */
-    static photoSettingsWithRawPixelFormatType$processedFormat$(rawPixelFormatType: NobjcObject, processedFormat: _NSDictionary | null): _AVCapturePhotoSettings;
+    static photoSettingsWithRawPixelFormatType$processedFormat$(rawPixelFormatType: number, processedFormat: _NSDictionary | null): _AVCapturePhotoSettings;
     /**
      * @method photoSettingsWithRawPixelFormatType:rawFileType:processedFormat:processedFileType: @abstract Creates an instance of AVCapturePhotoSettings specifying RAW + a processed format (such as JPEG) and a file container to which it will be written. @param rawPixelFormatType A Bayer RAW or Apple ProRAW pixel format OSType (defined in CVPixelBuffer.h). Pass 0 if you do not desire a RAW photo callback. @param rawFileType The file container for which the RAW image should be formatted to be written. Pass nil if you have no preferred file container. A default container will be chosen for you. @param processedFormat A dictionary of Core Video pixel buffer attributes or AVVideoSettings, analogous to AVCaptureStillImageOutput's outputSettings property. Pass nil if you do not desire a processed photo callback. @param processedFileType The file container for which the processed image should be formatted to be written. Pass nil if you have no preferred file container. A default container will be chosen for you. @result An instance of AVCapturePhotoSettings. @discussion rawPixelFormatType must be one of the OSTypes contained in AVCapturePhotoOutput's -availableRawPhotoPixelFormatTypes array. Set rawPixelFormatType to 0 if you do not desire a RAW photo callback. If you are specifying a rawFileType, it must be present in AVCapturePhotoOutput's -availableRawPhotoFileTypes array. If you wish an uncompressed processedFormat, your dictionary must contain kCVPixelBufferPixelFormatTypeKey, and the processedFormat specified must be present in AVCapturePhotoOutput's -availablePhotoPixelFormatTypes array. kCVPixelBufferPixelFormatTypeKey is the only supported key when expressing uncompressed processedFormat. If you wish a compressed format, your dictionary must contain AVVideoCodecKey and the codec specified must be present in AVCapturePhotoOutput's -availablePhotoCodecTypes array. If you are specifying a compressed format, the AVVideoCompressionPropertiesKey is also supported, with a payload dictionary containing a single AVVideoQualityKey. If you are specifying a processedFileType (such as AVFileTypeJPEG, AVFileTypeHEIC or AVFileTypeDICOM), it must be present in AVCapturePhotoOutput's -availablePhotoFileTypes array. Pass a nil processedFormat dictionary if you only desire a RAW photo capture. See AVCapturePhotoOutput's -capturePhotoWithSettings:delegate: inline documentation for a discussion of restrictions on AVCapturePhotoSettings when requesting RAW capture.
      */
-    static photoSettingsWithRawPixelFormatType$rawFileType$processedFormat$processedFileType$(rawPixelFormatType: NobjcObject, rawFileType: number | null, processedFormat: _NSDictionary | null, processedFileType: number | null): _AVCapturePhotoSettings;
+    static photoSettingsWithRawPixelFormatType$rawFileType$processedFormat$processedFileType$(rawPixelFormatType: number, rawFileType: _NSString | null, processedFormat: _NSDictionary | null, processedFileType: _NSString | null): _AVCapturePhotoSettings;
     /**
      * @method photoSettingsFromPhotoSettings: @abstract Creates an instance of AVCapturePhotoSettings with a new uniqueID from an existing instance of AVCapturePhotoSettings. @param photoSettings An existing AVCapturePhotoSettings instance. @result An new instance of AVCapturePhotoSettings with new uniqueID. @discussion Use this factory method to create a clone of an existing photo settings instance, but with a new uniqueID that can safely be passed to AVCapturePhotoOutput -capturePhotoWithSettings:delegate:.
      */
@@ -51,15 +52,15 @@ export declare class _AVCapturePhotoSettings extends _NSObject {
     /**
      * @property processedFileType @abstract The file container for which the processed photo is formatted to be stored. @discussion The formatting of data within a photo buffer is often dependent on the file format intended for storage. For instance, a JPEG encoded photo buffer intended for storage in a JPEG (JPEG File Interchange Format) file differs from JPEG to be stored in HEIF. The HEIF-containerized JPEG buffer is tiled for readback efficiency and partitioned into the box structure dictated by the HEIF file format. Some codecs are only supported by AVCapturePhotoOutput if containerized. For instance, the AVVideoCodecTypeHEVC is only supported with AVFileTypeHEIF and AVFileTypeHEIC formatting. To discover which photo pixel format types and video codecs are supported for a given file type, you may query AVCapturePhotoOutput's -supportedPhotoPixelFormatTypesForFileType:, or -supportedPhotoCodecTypesForFileType: respectively.
      */
-    processedFileType(): number;
+    processedFileType(): _NSString;
     /**
      * @property rawPhotoPixelFormatType @abstract A Bayer RAW or Apple ProRAW pixel format OSType (defined in CVPixelBuffer.h). @discussion The rawPixelFormatType you specified in one of the creation methods. Returns 0 if you did not specify RAW capture. See AVCapturePhotoOutput's -capturePhotoWithSettings:delegate: inline documentation for a discussion of restrictions on AVCapturePhotoSettings when requesting RAW capture.
      */
-    rawPhotoPixelFormatType(): NobjcObject;
+    rawPhotoPixelFormatType(): number;
     /**
      * @property rawFileType @abstract The file container for which the RAW photo is formatted to be stored. @discussion The formatting of data within a RAW photo buffer may be dependent on the file format intended for storage. To discover which RAW photo pixel format types are supported for a given file type, you may query AVCapturePhotoOutput's -supportedRawPhotoPixelFormatTypesForFileType:.
      */
-    rawFileType(): number | null;
+    rawFileType(): _NSString | null;
     /**
      * @property flashMode @abstract Specifies whether the flash should be on, off, or chosen automatically by AVCapturePhotoOutput. @discussion flashMode takes the place of the deprecated AVCaptureDevice -flashMode API. Setting AVCaptureDevice.flashMode has no effect on AVCapturePhotoOutput, which only pays attention to the flashMode specified in your AVCapturePhotoSettings. The default value is AVCaptureFlashModeOff. Flash modes are defined in AVCaptureDevice.h. If you specify a flashMode of AVCaptureFlashModeOn, it wins over autoStillImageStabilizationEnabled=YES. When the device becomes very hot, the flash becomes temporarily unavailable until the device cools down (see AVCaptureDevice's -flashAvailable). While the flash is unavailable, AVCapturePhotoOutput's -supportedFlashModes property still reports AVCaptureFlashModeOn and AVCaptureFlashModeAuto as being available, thus allowing you to specify a flashMode of AVCaptureModeOn. You should always check the AVCaptureResolvedPhotoSettings provided to you in the AVCapturePhotoCaptureDelegate callbacks, as the resolved flashEnabled property will tell you definitively if the flash is being used.
      */
@@ -222,3 +223,5 @@ export declare class _AVCapturePhotoSettings extends _NSObject {
     shutterSoundSuppressionEnabled(): boolean;
     setShutterSoundSuppressionEnabled$(value: boolean): void;
 }
+export interface _AVCapturePhotoSettings extends _NSCopying {
+}

package/dist/AVFoundation/AVCaptureSession.d.ts

@@ -63,7 +63,7 @@ export declare class _AVCaptureSession extends _NSObject {
     /**
      * @method setControlsDelegate:queue: @abstract Sets the receiver's controls delegate that receives events about the session's controls and the dispatch queue on which the delegate is called. @param controlsDelegate An object conforming to the `AVCaptureSessionControlsDelegate` protocol that receives events about the session's controls. @param controlsDelegateCallbackQueue A dispatch queue on which all delegate methods are called. @discussion Users can interact with an `AVCaptureSession`'s controls by performing specific gestures to enable their visibility. A delegate may be specified to be informed when the controls can be interacted with and are dismissed. All delegate methods will be called on the specified dispatch queue. A serial dispatch queue must be used to guarantee that delegate callbacks will be delivered in order. The `controlsDelegateCallbackQueue` parameter may not be `NULL`, except when setting the `controlsDelegate` to `nil` otherwise `-setControlsDelegate:queue:` throws an `NSInvalidArgumentException`.
      */
-    setControlsDelegate$queue$(controlsDelegate: _AVCaptureSessionControlsDelegate | null, controlsDelegateCallbackQueue: NobjcObject): void;
+    setControlsDelegate$queue$(controlsDelegate: _AVCaptureSessionControlsDelegate | null, controlsDelegateCallbackQueue: _NSObject | null): void;
     /**
      * @method canAddControl: @abstract Returns whether the proposed control can be added to the session. @param control An `AVCaptureControl` instance. @result `YES` if the proposed control can be added to the session, `NO` otherwise. @discussion An `AVCaptureControl` instance can only be added to a session using `-addControl:` if `-canAddControl:` returns `YES`. For example, some platforms do not support controls. Instances of `AVCaptureSlider`, `AVCaptureToggle` and `AVCaptureIndexPicker` must have an action and an action queue set before being added to a session.
      */
@@ -99,7 +99,7 @@ export declare class _AVCaptureSession extends _NSObject {
     /**
      * Sets a delegate object for the session to call when performing deferred start. This delegate receives a call to the ``AVCaptureSessionDeferredStartDelegate/sessionWillRunDeferredStart:`` method when deferred start is about to run. It is non-blocking, so by the time this method is called, the deferred start may already be underway. If you want your app to perform initialization (potentially) concurrently with deferred start (e.g. user-facing camera features that are not needed to display the first preview frame, but are available to the user as soon as possible) it may be done in the delegate's ``AVCaptureSessionDeferredStartDelegate/sessionWillRunDeferredStart:`` method. To wait until deferred start is finished to perform some remaining initialization work, use the ``AVCaptureSessionDeferredStartDelegate/sessionDidRunDeferredStart:`` method instead. The delegate receives a call to the ``AVCaptureSessionDeferredStartDelegate/sessionDidRunDeferredStart:`` method when the deferred start finishes running. This allows you to run less-critical application initialization code. For example, if you've deferred an ``AVCapturePhotoOutput`` by setting its ``AVCaptureOutput/deferredStartEnabled`` property to `true`, and you'd like to do some app-specific initialization related to still capture, here might be a good place to put it. If the delegate is non-nil, the session still calls the ``AVCaptureSessionDeferredStartDelegate/sessionWillRunDeferredStart:`` and ``AVCaptureSessionDeferredStartDelegate/sessionDidRunDeferredStart:`` methods regardless of the value of the session's ``automaticallyRunsDeferredStart`` property. To minimize the capture session's startup latency, defer all unnecessary work until after the session starts. This delegate provides callbacks for you to schedule deferred work without impacting session startup performance. To perform initialization prior to deferred start but after the user interface displays, set ``automaticallyRunsDeferredStart`` to `false`, and then run the custom initialization prior to calling ``runDeferredStartWhenNeeded``. If ``deferredStartDelegate`` is not `NULL`, the session throws an exception if ``deferredStartDelegateCallbackQueue`` is `nil`. - Parameter deferredStartDelegate: An object conforming to the ``AVCaptureSessionDeferredStartDelegate`` protocol that receives events about deferred start. - Parameter deferredStartDelegateCallbackQueue: A dispatch queue on which deferredStart delegate methods are called.
      */
-    setDeferredStartDelegate$deferredStartDelegateCallbackQueue$(deferredStartDelegate: _AVCaptureSessionDeferredStartDelegate | null, deferredStartDelegateCallbackQueue: NobjcObject): void;
+    setDeferredStartDelegate$deferredStartDelegateCallbackQueue$(deferredStartDelegate: _AVCaptureSessionDeferredStartDelegate | null, deferredStartDelegateCallbackQueue: _NSObject | null): void;
     /**
      * @property sessionPreset @abstract Indicates the session preset currently in use by the receiver. @discussion The value of this property is an AVCaptureSessionPreset indicating the current session preset in use by the receiver. The sessionPreset property may be set while the receiver is running.
      */
@@ -132,7 +132,7 @@ export declare class _AVCaptureSession extends _NSObject {
     /**
      * @property controlsDelegateCallbackQueue @abstract The dispatch queue on which all controls delegate methods will be called. @discussion The value of this property is a `dispatch_queue_t`. The queue is set using the `-setControlsDelegate:queue:` method.
      */
-    controlsDelegateCallbackQueue(): NobjcObject;
+    controlsDelegateCallbackQueue(): _NSObject;
     /**
      * @property controls @abstract An `NSArray` of `AVCaptureControl`s currently added to the session. @discussion The value of this property is an `NSArray` of `AVCaptureControl`s currently added to the session. Clients can add `AVCaptureControl`s to a session by calling `-addControl:`.
      */
@@ -182,12 +182,12 @@ export declare class _AVCaptureSession extends _NSObject {
     /**
      * @property synchronizationClock @abstract Provides the clock being used for synchronization. @discussion synchronizationClock is readonly. Use synchronizationClock to synchronize AVCaptureOutput data with external data sources (e.g motion samples). All capture output sample buffer timestamps are on the synchronizationClock timebase. For example, if you want to reverse synchronize the output timestamps to the original timestamps, you can do the following: In captureOutput:didOutputSampleBuffer:fromConnection: AVCaptureInputPort *port = [[connection inputPorts] objectAtIndex:0]; CMClockRef originalClock = [port clock]; CMTime syncedPTS = CMSampleBufferGetPresentationTime( sampleBuffer ); CMTime originalPTS = CMSyncConvertTime( syncedPTS, [session synchronizationClock], originalClock ); This property is key-value observable.
      */
-    synchronizationClock(): NobjcObject;
+    synchronizationClock(): NobjcObject | null;
     /**
      * @property masterClock @abstract Provides the clock being used for synchronization. @discussion Deprecated. Please use synchronizationClock instead.
      * @deprecated synchronizationClock
      */
-    masterClock(): NobjcObject;
+    masterClock(): NobjcObject | null;
     /**
      * @property hardwareCost @abstract Indicates the percentage of the session's available hardware budget currently in use. @discussion The value of this property is a float from 0.0 => 1.0 indicating how much of the session's available hardware is in use as a percentage, given the currently connected inputs and outputs and the features for which you've opted in. When your hardwareCost is greater than 1.0, the capture session cannot run your desired configuration due to hardware constraints, so you receive an AVCaptureSessionRuntimeErrorNotification when attempting to start it running. Default value is 0. Contributors to hardwareCost include: - Whether the source device's active format uses the full sensor (4:3) or a crop (16:9). Cropped formats require lower hardware bandwidth, and therefore lower the cost. - The max frame rate supported by the source device's active format. The higher the max frame rate, the higher the cost. - Whether the source device's active format is binned or not. Binned formats require substantially less hardware bandwidth, and therefore result in a lower cost. - The number of sources configured to deliver streaming disparity / depth via AVCaptureDepthDataOutput. The higher the number of cameras configured to produce depth, the higher the cost. For AVCaptureMultiCamSessions, all of the source devices' active formats contribute to hardwareCost. In order to reduce hardwareCost, consider picking a sensor-cropped activeFormat, or a binned format. You may also use AVCaptureDeviceInput's videoMinFrameDurationOverride property to artificially limit the max frame rate (which is the reciprocal of the min frame duration) of a source device to a lower value. By doing so, you only pay the hardware cost for the max frame rate you intend to use. AVCaptureMultiCamSessions always computes this hardwareCost. AVCaptureSessions only computes a non-zero hardwareCost when multiple AVCaptureVideoDataOutputs or an AVCaptureMovieFileOutput and one or more AVCaptureVideoDataOutputs are added to the session.
      */
@@ -208,5 +208,5 @@ export declare class _AVCaptureSession extends _NSObject {
     /**
      * The dispatch queue on which the session calls deferred start delegate methods. Call the ``setDeferredStartDelegate:deferredStartDelegateCallbackQueue:`` method to specify the dispatch queue on which to call the deferred start delegate methods.
      */
-    deferredStartDelegateCallbackQueue(): NobjcObject;
+    deferredStartDelegateCallbackQueue(): _NSObject;
 }

package/dist/AVFoundation/AVCaptureSlider.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _AVCaptureControl } from "./AVCaptureControl.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export declare class _AVCaptureSlider extends _AVCaptureControl {
     static alloc(): _AVCaptureSlider;
@@ -21,7 +22,7 @@ export declare class _AVCaptureSlider extends _AVCaptureControl {
     /**
      * @method setActionQueue:action: @abstract Configures the slider's `action` which is called on `actionQueue` whenever the value of the slider is changed. @param actionQueue A queue for the `action` to be called. @param action An action called on `actionQueue` whenever the value of the slider is changed. @discussion Because the camera system may be independent from the main thread or `@MainActor`, `action` is always called on an internal `DispatchSerialQueue` targeted at `actionQueue`. If `action` modifies a property of the camera system, `actionQueue` must represent the same exclusive execution context as the camera system (see `isSameExclusiveExecutionContext`).
      */
-    setActionQueue$action$(actionQueue: NobjcObject, action: NobjcObject): void;
+    setActionQueue$action$(actionQueue: _NSObject, action: NobjcObject): void;
     /**
      * @property value @abstract The current value of the slider. @discussion Because the camera system may be independent from the main thread or `@MainActor`, `value` must be changed on `actionQueue` – the queue provided to `setActionQueue:action:`. The default value is the slider's minimum value. A value may only be set if it is within the slider's minimum and maximum values, otherwise an `NSInvalidArgumentException` is thrown.
      */

package/dist/AVFoundation/AVCaptureSmartFramingMonitor.d.ts

@@ -9,7 +9,7 @@ export declare class _AVCaptureSmartFramingMonitor extends _NSObject {
     /**
      * Begins monitoring the device's active scene and making framing recommendations. - Parameter outError: A pointer to an ``NSError`` indicating why ``startMonitoringWithError:`` failed, or to a `nil` ``NSError`` on success. - Returns: `true` if successful, `false` if monitoring could not be started. The monitor's ``recommendedFraming`` is `nil` when it is not actively running. Call this method to start monitoring. You may start monitoring before or after calling ``AVCaptureSession/startRunning``, and you may stop active monitoring without stopping the capture session by calling ``stopMonitoring`` at any time, but you must set ``enabledFramings`` before running your capture session so that the monitor is prepared for your desired framing recommendations. While the monitor is running, you may set ``enabledFramings`` at any time to change the framing choices the monitor should consider in its recommendations.
      */
-    startMonitoringWithError$(outError: NobjcObject): boolean;
+    startMonitoringWithError$(outError: NobjcObject | null): boolean;
     /**
      * Stops monitoring the device's active scene and making framing recommendations. The monitor's ``recommendedFraming`` is `nil` when it is not actively running. Call this method to stop actively monitoring the scene and making framing recommendations. You may start monitoring before or after calling ``AVCaptureSession/startRunning``, and may stop active monitoring without stopping the capture session by calling ``stopMonitoring`` at any time.
      */

package/dist/AVFoundation/AVCaptureSpatialAudioMetadataSampleGenerator.d.ts

@@ -7,11 +7,11 @@ export declare class _AVCaptureSpatialAudioMetadataSampleGenerator extends _NSOb
     /**
      * Analyzes the provided audio sample buffer for its contribution to the spatial audio timed metadata value. - Parameter sbuf: a sample buffer containing spatial audio. - Returns: `noErr` if the sample is successfully analyzed, otherwise a non-zero error code. You must call this method with each and every spatial audio buffer you provide to ``AVAssetWriter``, so it can be analyzed for the generation of a proper spatial audio timed metadata value.
      */
-    analyzeAudioSample$(sbuf: NobjcObject): NobjcObject;
+    analyzeAudioSample$(sbuf: NobjcObject): number;
     /**
      * Creates a sample buffer containing a spatial audio timed metadata sample computed from all analyzed audio buffers, and resets the analyzer to its initial state. - Returns: a ``CMSampleBufferRef`` containing the spatial audio timed metadata sample, or `NULL` if no value can be computed. Call this method after you pass the last audio sample buffer of your recording to ``analyzeAudioSample:``. Then pass the returned ``CMSampleBufferRef`` directly to your ``AVAssetWriterInput`` to add the sample to your recording's audio timed metadata track. Note that ``AVAssetWriter`` expects one and only one spatial audio metadata sample buffer to be present in the timed metadata track. - Note: Calling this method also resets the analyzer, making it ready for another run of audio sample buffers. Thus one generator can be re-used for multiple recordings.
      */
-    newTimedMetadataSampleBufferAndResetAnalyzer(): NobjcObject;
+    newTimedMetadataSampleBufferAndResetAnalyzer(): NobjcObject | null;
     /**
      * Calling this method resets the analyzer to its initial state so that a new run of audio sample buffers can be analyzed. Call this method if you need to abort generating the audio timed metadata buffer for audio already provided to ``analyzeAudioSample:``.
      */

package/dist/AVFoundation/AVCaptureStillImageOutput.d.ts

@@ -15,17 +15,17 @@ export declare class _AVCaptureStillImageOutput extends _AVCaptureOutput {
     /**
      * @method captureStillImageAsynchronouslyFromConnection:completionHandler: @abstract Initiates an asynchronous still image capture, returning the result to a completion handler. @param connection The AVCaptureConnection object from which to capture the still image. @param handler A block that will be called when the still image capture is complete. The block will be passed a CMSampleBuffer object containing the image data or an NSError object if an image could not be captured. @discussion This method will return immediately after it is invoked, later calling the provided completion handler block when image data is ready. If the request could not be completed, the error parameter will contain an NSError object describing the failure. Attachments to the image data sample buffer may contain metadata appropriate to the image data format. For instance, a sample buffer containing JPEG data may carry a kCGImagePropertyExifDictionary as an attachment. See <ImageIO/CGImageProperties.h> for a list of keys and value types. Clients should not assume that the completion handler will be called on a specific thread. Calls to captureStillImageAsynchronouslyFromConnection:completionHandler: are not synchronized with AVCaptureDevice manual control completion handlers. Setting a device manual control, waiting for its completion, then calling captureStillImageAsynchronouslyFromConnection:completionHandler: DOES NOT ensure that the still image returned reflects your manual control change. It may be from an earlier time. You can compare your manual control completion handler sync time to the returned still image's presentation time. You can retrieve the sample buffer's pts using CMSampleBufferGetPresentationTimestamp(). If the still image has an earlier timestamp, your manual control command does not apply to it.
      */
-    captureStillImageAsynchronouslyFromConnection$completionHandler$(connection: _AVCaptureConnection, handler: NobjcObject): void;
+    captureStillImageAsynchronouslyFromConnection$completionHandler$(connection: _AVCaptureConnection, handler: NobjcObject | null): void;
     /**
      * @method prepareToCaptureStillImageBracketFromConnection:withSettingsArray:completionHandler: @abstract Allows the receiver to prepare resources in advance of capturing a still image bracket. @param connection The connection through which the still image bracket should be captured. @param settings An array of AVCaptureBracketedStillImageSettings objects. All must be of the same kind of AVCaptureBracketedStillImageSettings subclass, or an NSInvalidArgumentException is thrown. @param handler A user provided block that will be called asynchronously once resources have successfully been allocated for the specified bracketed capture operation. If sufficient resources could not be allocated, the "prepared" parameter contains NO, and "error" parameter contains a non-nil error value. If [settings count] exceeds -maxBracketedCaptureStillImageCount, then AVErrorMaximumStillImageCaptureRequestsExceeded is returned. You should not assume that the completion handler will be called on a specific thread. @discussion -maxBracketedCaptureStillImageCount tells you the maximum number of images that may be taken in a single bracket given the current AVCaptureDevice/AVCaptureSession/AVCaptureStillImageOutput configuration. But before taking a still image bracket, additional resources may need to be allocated. By calling -prepareToCaptureStillImageBracketFromConnection:withSettingsArray:completionHandler: first, you are able to deterministically know when the receiver is ready to capture the bracket with the specified settings array.
      * @deprecated Use AVCapturePhotoOutput setPreparedPhotoSettingsArray:completionHandler: instead.
      */
-    prepareToCaptureStillImageBracketFromConnection$withSettingsArray$completionHandler$(connection: _AVCaptureConnection, settings: _NSArray, handler: NobjcObject): void;
+    prepareToCaptureStillImageBracketFromConnection$withSettingsArray$completionHandler$(connection: _AVCaptureConnection, settings: _NSArray, handler: NobjcObject | null): void;
     /**
      * @method captureStillImageBracketAsynchronouslyFromConnection:withSettingsArray:completionHandler: @abstract Captures a still image bracket. @param connection The connection through which the still image bracket should be captured. @param settings An array of AVCaptureBracketedStillImageSettings objects. All must be of the same kind of AVCaptureBracketedStillImageSettings subclass, or an NSInvalidArgumentException is thrown. @param handler A user provided block that will be called asynchronously as each still image in the bracket is captured. If the capture request is successful, the "sampleBuffer" parameter contains a valid CMSampleBuffer, the "stillImageSettings" parameter contains the settings object corresponding to this still image, and a nil "error" parameter. If the bracketed capture fails, sample buffer is NULL and error is non-nil. If [settings count] exceeds -maxBracketedCaptureStillImageCount, then AVErrorMaximumStillImageCaptureRequestsExceeded is returned. You should not assume that the completion handler will be called on a specific thread. @discussion If you have not called -prepareToCaptureStillImageBracketFromConnection:withSettingsArray:completionHandler: for this still image bracket request, the bracket may not be taken immediately, as the receiver may internally need to prepare resources.
      * @deprecated Use AVCapturePhotoOutput capturePhotoWithSettings:delegate: instead.
      */
-    captureStillImageBracketAsynchronouslyFromConnection$withSettingsArray$completionHandler$(connection: _AVCaptureConnection, settings: _NSArray, handler: NobjcObject): void;
+    captureStillImageBracketAsynchronouslyFromConnection$withSettingsArray$completionHandler$(connection: _AVCaptureConnection, settings: _NSArray, handler: NobjcObject | null): void;
     /**
      * @property outputSettings @abstract Specifies the options the receiver uses to encode still images before they are delivered. @discussion See AVVideoSettings.h for more information on how to construct an output settings dictionary. On iOS, the only currently supported keys are AVVideoCodecKey and kCVPixelBufferPixelFormatTypeKey. Use -availableImageDataCVPixelFormatTypes and -availableImageDataCodecTypes to determine what codec keys and pixel formats are supported. AVVideoQualityKey is supported on iOS 6.0 and later and may only be used when AVVideoCodecKey is set to AVVideoCodecTypeJPEG.
      */

package/dist/AVFoundation/AVCaptureSynchronizedDataCollection.d.ts

@@ -1,3 +1,4 @@
+import type { _NSFastEnumeration } from "../Foundation/NSFastEnumeration.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVCaptureOutput } from "./AVCaptureOutput.js";
 import type { _AVCaptureSynchronizedData } from "./AVCaptureSynchronizedData.js";
@@ -18,3 +19,5 @@ export declare class _AVCaptureSynchronizedDataCollection extends _NSObject {
      */
     count(): number;
 }
+export interface _AVCaptureSynchronizedDataCollection extends _NSFastEnumeration {
+}

package/dist/AVFoundation/AVCaptureTimecodeGenerator.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVCaptureTimecodeGeneratorDelegate } from "./AVCaptureTimecodeGeneratorDelegate.js";
@@ -20,7 +19,7 @@ export declare class _AVCaptureTimecodeGenerator extends _NSObject {
     /**
      * Assigns a delegate to receive real-time timecode updates and specifies a queue for callbacks. - Parameter delegate: An object conforming to the ``AVCaptureTimecodeGeneratorDelegate`` protocol. - Parameter callbackQueue: The dispatch queue on which the delegate methods are invoked. The `callbackQueue` parameter may not be `nil`, except when setting the ``AVCaptureTimecodeGeneratorDelegate`` to `nil`, otherwise ``setDelegate:queue:`` throws an `NSInvalidArgumentException`. Use this method to configure a delegate that handles timecode updates. The specified `queue` ensures thread-safe invocation of delegate methods.
      */
-    setDelegate$queue$(delegate: _AVCaptureTimecodeGeneratorDelegate | null, callbackQueue: NobjcObject): void;
+    setDelegate$queue$(delegate: _AVCaptureTimecodeGeneratorDelegate | null, callbackQueue: _NSObject | null): void;
     /**
      * Synchronizes the generator with the specified timecode source. - Parameter source: The timecode source for synchronization.
      */
@@ -44,7 +43,7 @@ export declare class _AVCaptureTimecodeGenerator extends _NSObject {
     /**
      * The dispatch queue on which delegate callbacks are invoked. Provides the queue set in ``setDelegate:queue:``. If no delegate is assigned, this property is `nil`.
      */
-    delegateCallbackQueue(): NobjcObject;
+    delegateCallbackQueue(): _NSObject | null;
     /**
      * The maximum time interval allowed for source synchronization attempts before timing out. This property specifies the duration, in seconds, that the ``AVCaptureTimecodeGenerator`` will attempt to synchronize with a timecode source before timing out if synchronization cannot be achieved. If this threshold is exceeded, the synchronization status updates to reflect a timeout, and your ``AVCaptureTimecodeGeneratorDelegate/timecodeGenerator:transitionedToSynchronizationStatus:forSource:`` delegate method fires, informing you of the event. The default value is 15 seconds.
      */

package/dist/AVFoundation/AVCaptureTimecodeSource.d.ts

@@ -1,3 +1,4 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSUUID } from "../Foundation/NSUUID.js";
@@ -19,3 +20,5 @@ export declare class _AVCaptureTimecodeSource extends _NSObject {
      */
     uuid(): _NSUUID;
 }
+export interface _AVCaptureTimecodeSource extends _NSCopying {
+}

package/dist/AVFoundation/AVCaptureVideoDataOutput.d.ts

@@ -1,8 +1,9 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCaptureOutput } from "./AVCaptureOutput.js";
 import type { _AVCaptureVideoDataOutputSampleBufferDelegate } from "./AVCaptureVideoDataOutputSampleBufferDelegate.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { CMTime } from "../structs/CMTime.js";
 import type { AVVideoCodecType } from "./AVVideoCodecType.js";
@@ -13,27 +14,27 @@ export declare class _AVCaptureVideoDataOutput extends _AVCaptureOutput {
     /**
      * @method setSampleBufferDelegate:queue: @abstract Sets the receiver's delegate that will accept captured buffers and dispatch queue on which the delegate will be called. @param sampleBufferDelegate An object conforming to the AVCaptureVideoDataOutputSampleBufferDelegate protocol that will receive sample buffers after they are captured. @param sampleBufferCallbackQueue A dispatch queue on which all sample buffer delegate methods will be called. @discussion When a new video sample buffer is captured it will be vended to the sample buffer delegate using the captureOutput:didOutputSampleBuffer:fromConnection: delegate method. All delegate methods will be called on the specified dispatch queue. If the queue is blocked when new frames are captured, those frames will be automatically dropped at a time determined by the value of the alwaysDiscardsLateVideoFrames property. This allows clients to process existing frames on the same queue without having to manage the potential memory usage increases that would otherwise occur when that processing is unable to keep up with the rate of incoming frames. If their frame processing is consistently unable to keep up with the rate of incoming frames, clients should consider using the minFrameDuration property, which will generally yield better performance characteristics and more consistent frame rates than frame dropping alone. Clients that need to minimize the chances of frames being dropped should specify a queue on which a sufficiently small amount of processing is being done outside of receiving sample buffers. However, if such clients migrate extra processing to another queue, they are responsible for ensuring that memory usage does not grow without bound from frames that have not been processed. A serial dispatch queue must be used to guarantee that video frames will be delivered in order. The sampleBufferCallbackQueue parameter may not be NULL, except when setting the sampleBufferDelegate to nil otherwise -setSampleBufferDelegate:queue: throws an NSInvalidArgumentException.
      */
-    setSampleBufferDelegate$queue$(sampleBufferDelegate: _AVCaptureVideoDataOutputSampleBufferDelegate | null, sampleBufferCallbackQueue: NobjcObject): void;
+    setSampleBufferDelegate$queue$(sampleBufferDelegate: _AVCaptureVideoDataOutputSampleBufferDelegate | null, sampleBufferCallbackQueue: _NSObject | null): void;
     /**
      * @method recommendedVideoSettingsForAssetWriterWithOutputFileType: @abstract Specifies the recommended settings for use with an AVAssetWriterInput. @param outputFileType Specifies the UTI of the file type to be written (see AVMediaFormat.h for a list of file format UTIs). @result A fully populated dictionary of keys and values that are compatible with AVAssetWriter. @discussion The value of this property is an NSDictionary containing values for compression settings keys defined in AVVideoSettings.h. This dictionary is suitable for use as the "outputSettings" parameter when creating an AVAssetWriterInput, such as, [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:outputSettings sourceFormatHint:hint]; The dictionary returned contains all necessary keys and values needed by AVAssetWriter (see AVAssetWriterInput.h, -initWithMediaType:outputSettings: for a more in depth discussion). For QuickTime movie and ISO file types, the recommended video settings will produce output comparable to that of AVCaptureMovieFileOutput. Note that the dictionary of settings is dependent on the current configuration of the receiver's AVCaptureSession and its inputs. The settings dictionary may change if the session's configuration changes. As such, you should configure your session first, then query the recommended video settings. As of iOS 8.3, movies produced with these settings successfully import into the iOS camera roll and sync to and from like devices via iTunes.
      */
-    recommendedVideoSettingsForAssetWriterWithOutputFileType$(outputFileType: number): _NSDictionary | null;
+    recommendedVideoSettingsForAssetWriterWithOutputFileType$(outputFileType: _NSString): _NSDictionary | null;
     /**
      * @method availableVideoCodecTypesForAssetWriterWithOutputFileType: @abstract Specifies the available video codecs for use with AVAssetWriter and a given file type. @param outputFileType Specifies the UTI of the file type to be written (see AVMediaFormat.h for a list of file format UTIs). @result An array of video codecs; see AVVideoSettings.h for a full list. @discussion This method allows you to query the available video codecs that may be used when specifying an AVVideoCodecKey in -recommendedVideoSettingsForVideoCodecType:assetWriterOutputFileType:. When specifying an outputFileType of AVFileTypeQuickTimeMovie, video codecs are ordered identically to -[AVCaptureMovieFileOutput availableVideoCodecTypes].
      */
-    availableVideoCodecTypesForAssetWriterWithOutputFileType$(outputFileType: number): _NSArray;
+    availableVideoCodecTypesForAssetWriterWithOutputFileType$(outputFileType: _NSString): _NSArray;
     /**
      * @method recommendedVideoSettingsForVideoCodecType:assetWriterOutputFileType: @abstract Specifies the recommended settings for a particular video codec type, to be used with an AVAssetWriterInput. @param videoCodecType Specifies the desired AVVideoCodecKey to be used for compression (see AVVideoSettings.h). @param outputFileType Specifies the UTI of the file type to be written (see AVMediaFormat.h for a list of file format UTIs). @result A fully populated dictionary of keys and values that are compatible with AVAssetWriter. @discussion The value of this property is an NSDictionary containing values for compression settings keys defined in AVVideoSettings.h. This dictionary is suitable for use as the "outputSettings" parameter when creating an AVAssetWriterInput, such as, [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:outputSettings sourceFormatHint:hint]; The dictionary returned contains all necessary keys and values needed by AVAssetWriter (see AVAssetWriterInput.h, -initWithMediaType:outputSettings: for a more in depth discussion). For QuickTime movie and ISO file types, the recommended video settings will produce output comparable to that of AVCaptureMovieFileOutput. The videoCodecType string provided must be present in the availableVideoCodecTypesForAssetWriterWithOutputFileType: array, or an NSInvalidArgumentException is thrown. Note that the dictionary of settings is dependent on the current configuration of the receiver's AVCaptureSession and its inputs. The settings dictionary may change if the session's configuration changes. As such, you should configure your session first, then query the recommended video settings. As of iOS 8.3, movies produced with these settings successfully import into the iOS camera roll and sync to and from like devices via iTunes.
      */
-    recommendedVideoSettingsForVideoCodecType$assetWriterOutputFileType$(videoCodecType: AVVideoCodecType, outputFileType: number): _NSDictionary | null;
+    recommendedVideoSettingsForVideoCodecType$assetWriterOutputFileType$(videoCodecType: AVVideoCodecType, outputFileType: _NSString): _NSDictionary | null;
     /**
      * @method recommendedVideoSettingsForVideoCodecType:assetWriterOutputFileType:outputFileURL: @abstract Specifies the recommended settings for a particular video codec type with output file URL, to be used with an AVAssetWriterInput. @param videoCodecType Specifies the desired AVVideoCodecKey to be used for compression (see AVVideoSettings.h). @param outputFileType Specifies the UTI of the file type to be written (see AVMediaFormat.h for a list of file format UTIs). @param outputFileURL Specifies the output URL of the file to be written. If you wish to capture onto an external storage device get an externalStorageDevice of type AVExternalStorageDevice (as defined in AVExternalStorageDevice.h): [AVExternalStorageDeviceDiscoverySession sharedSession] externalStorageDevices] Then use [externalStorageDevice nextAvailableURLsWithPathExtensions:pathExtensions error:&error] to get the output file URL. @result A fully populated dictionary of keys and values that are compatible with AVAssetWriter. @discussion The value of this property is an NSDictionary containing values for compression settings keys defined in AVVideoSettings.h. This dictionary is suitable for use as the "outputSettings" parameter when creating an AVAssetWriterInput, such as, [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:outputSettings sourceFormatHint:hint]; The dictionary returned contains all necessary keys and values needed by AVAssetWriter (see AVAssetWriterInput.h, -initWithMediaType:outputSettings: for a more in depth discussion). For QuickTime movie and ISO file types, the recommended video settings will produce output comparable to that of AVCaptureMovieFileOutput. The videoCodecType string provided must be present in the availableVideoCodecTypesForAssetWriterWithOutputFileType: array, or an NSInvalidArgumentException is thrown. Note that the dictionary of settings is dependent on the current configuration of the receiver's AVCaptureSession and its inputs. The settings dictionary may change if the session's configuration changes. As such, you should configure your session first, then query the recommended video settings. As of iOS 8.3, movies produced with these settings successfully import into the iOS camera roll and sync to and from like devices via iTunes.
      */
-    recommendedVideoSettingsForVideoCodecType$assetWriterOutputFileType$outputFileURL$(videoCodecType: AVVideoCodecType, outputFileType: number, outputFileURL: _NSURL | null): _NSDictionary | null;
+    recommendedVideoSettingsForVideoCodecType$assetWriterOutputFileType$outputFileURL$(videoCodecType: AVVideoCodecType, outputFileType: _NSString, outputFileURL: _NSURL | null): _NSDictionary | null;
     /**
      * Recommends movie-level metadata for a particular video codec type and output file type, to be used with an asset writer input. - Parameter videoCodecType: The desired ``AVVideoCodecKey`` to be used for compression (see <doc://com.apple.documentation/documentation/avfoundation/video-settings>). - Parameter outputFileType: Specifies the UTI of the file type to be written (see <doc://com.apple.documentation/documentation/avfoundation/avfiletype>). - Returns: A fully populated array of ``AVMetadataItem`` objects compatible with ``AVAssetWriter``. The value of this property is an array of ``AVMetadataItem`` objects representing the collection of top-level metadata to be written in each output file. This array is suitable to use as the ``AVAssetWriter/metadata`` property before you have called ``AVAssetWriter/startWriting``. For more details see <doc://com.apple.documentation/documentation/avfoundation/avassetwriter/startwriting()>. The ``videoCodecType`` string you provide must be present in ``availableVideoCodecTypesForAssetWriterWithOutputFileType:`` array, or an `NSInvalidArgumentException` is thrown. For clients writing files using a ProRes Raw codec type, white balance must be locked (call ``AVCaptureDevice/setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains:completionHandler:``) before querying this property, or an `NSIvalidArgumentException` is thrown. - Note: The array of metadata is dependent on the current configuration of the receiver's ``AVCaptureSession`` and its inputs. The array may change when the session's configuration changes. As such, you should configure and start your session first, then query this method.
      */
-    recommendedMovieMetadataForVideoCodecType$assetWriterOutputFileType$(videoCodecType: AVVideoCodecType, outputFileType: number): _NSArray | null;
+    recommendedMovieMetadataForVideoCodecType$assetWriterOutputFileType$(videoCodecType: AVVideoCodecType, outputFileType: _NSString): _NSArray | null;
     /**
      * @property sampleBufferDelegate @abstract The receiver's delegate. @discussion The value of this property is an object conforming to the AVCaptureVideoDataOutputSampleBufferDelegate protocol that will receive sample buffers after they are captured. The delegate is set using the setSampleBufferDelegate:queue: method.
      */
@@ -41,7 +42,7 @@ export declare class _AVCaptureVideoDataOutput extends _AVCaptureOutput {
     /**
      * @property sampleBufferCallbackQueue @abstract The dispatch queue on which all sample buffer delegate methods will be called. @discussion The value of this property is a dispatch_queue_t. The queue is set using the setSampleBufferDelegate:queue: method.
      */
-    sampleBufferCallbackQueue(): NobjcObject;
+    sampleBufferCallbackQueue(): _NSObject | null;
     /**
      * @property videoSettings @abstract Specifies the settings used to decode or re-encode video before it is output by the receiver. @discussion See AVVideoSettings.h for more information on how to construct a video settings dictionary. To receive samples in their device native format, set this property to an empty dictionary (i.e. [NSDictionary dictionary]). To receive samples in a default uncompressed format, set this property to nil. Note that after this property is set to nil, subsequent querying of this property will yield a non-nil dictionary reflecting the settings used by the AVCaptureSession's current sessionPreset. On iOS versions prior to iOS 16.0, the only supported key is kCVPixelBufferPixelFormatTypeKey. Use -availableVideoCVPixelFormatTypes for the list of supported pixel formats. For apps linked on or after iOS 16.0, kCVPixelBufferPixelFormatTypeKey, kCVPixelBufferWidthKey, and kCVPixelBufferHeightKey are supported. The width and height must match the videoOrientation specified on the output's AVCaptureConnection or an NSInvalidArgumentException is thrown. The aspect ratio of width and height must match the aspect ratio of the source's activeFormat (corrected for the connection's videoOrientation) or an NSInvalidArgumentException is thrown. If width or height exceeds the source's activeFormat's width or height, an NSInvalidArgumentException is thrown. Changing width and height when deliversPreviewSizedOutputBuffers is set to YES is not supported and throws an NSInvalidArgumentException.
      */
@@ -50,7 +51,7 @@ export declare class _AVCaptureVideoDataOutput extends _AVCaptureOutput {
     /**
      * Indicates the recommended media timescale for the video track. - Returns: The recommended media timescale based on the active capture session's inputs. It is never less than 600. It may or may not be a multiple of 600.
      */
-    recommendedMediaTimeScaleForAssetWriter(): NobjcObject;
+    recommendedMediaTimeScaleForAssetWriter(): number;
     /**
      * @property availableVideoCVPixelFormatTypes @abstract Indicates the supported video pixel formats that can be specified in videoSettings. @discussion The value of this property is an NSArray of NSNumbers that can be used as values for the kCVPixelBufferPixelFormatTypeKey in the receiver's videoSettings property. The formats are listed in an unspecified order. This list can may change if the activeFormat of the AVCaptureDevice connected to the receiver changes.
      */

package/dist/AVFoundation/AVComposition.d.ts

@@ -5,6 +5,8 @@ import type { _AVMediaSelectionGroup } from "./AVMediaSelectionGroup.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSLocale } from "../Foundation/NSLocale.js";
+import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { CGSize } from "../structs/CGSize.js";
 import type { AVMetadataFormat } from "./AVMetadataFormat.js";
 export declare class _AVComposition extends _AVAsset {
@@ -14,32 +16,32 @@ export declare class _AVComposition extends _AVAsset {
     /**
      * Provides an instance of AVCompositionTrack that represents the track of the specified trackID. The trackID of the requested AVCompositionTrack. An instance of AVCompositionTrack; may be nil if no track of the specified trackID is available. Becomes callable without blocking when the key " tracks" has been loaded
      */
-    trackWithTrackID$(trackID: NobjcObject): _AVCompositionTrack | null;
+    trackWithTrackID$(trackID: number): _AVCompositionTrack | null;
     /**
      * Loads an instance of AVCompositionTrack that represents the track of the specified trackID. The trackID of the requested AVCompositionTrack. A block that is called when the loading is finished, with either the loaded track (which may be nil if no track of the specified trackID is available) or an error.
      */
-    loadTrackWithTrackID$completionHandler$(trackID: NobjcObject, completionHandler: NobjcObject): void;
+    loadTrackWithTrackID$completionHandler$(trackID: number, completionHandler: NobjcObject | null): void;
     /**
      * Provides an array of AVCompositionTracks of the asset that present media of the specified media type. The media type according to which the receiver filters its AVCompositionTracks. (Media types are defined in AVMediaFormat.h) An NSArray of AVCompositionTracks; may be empty if no tracks of the specified media type are available. Becomes callable without blocking when the key " tracks" has been loaded
      */
-    tracksWithMediaType$(mediaType: number): _NSArray;
+    tracksWithMediaType$(mediaType: _NSString): _NSArray;
     /**
      * Loads an array of AVCompositionTracks of the asset that present media of the specified media type. The media type according to which AVAsset filters its AVCompositionTracks. (Media types are defined in AVMediaFormat.h.) A block that is called when the loading is finished, with either the loaded tracks (which may be empty if no tracks of the specified media type are available) or an error.
      */
-    loadTracksWithMediaType$completionHandler$(mediaType: number, completionHandler: NobjcObject): void;
+    loadTracksWithMediaType$completionHandler$(mediaType: _NSString, completionHandler: NobjcObject | null): void;
     /**
      * Provides an array of AVCompositionTracks of the asset that present media with the specified characteristic. The media characteristic according to which the receiver filters its AVCompositionTracks. (Media characteristics are defined in AVMediaFormat.h) An NSArray of AVCompositionTracks; may be empty if no tracks with the specified characteristic are available. Becomes callable without blocking when the key " tracks" has been loaded
      */
-    tracksWithMediaCharacteristic$(mediaCharacteristic: number): _NSArray;
+    tracksWithMediaCharacteristic$(mediaCharacteristic: _NSString): _NSArray;
     /**
      * Loads an array of AVCompositionTracks of the asset that present media with the specified characteristic. The media characteristic according to which AVAsset filters its AVCompositionTracks. (Media characteristics are defined in AVMediaFormat.h.) A block that is called when the loading is finished, with either the loaded tracks (which may be empty if no tracks with the specified characteristic are available) or an error.
      */
-    loadTracksWithMediaCharacteristic$completionHandler$(mediaCharacteristic: number, completionHandler: NobjcObject): void;
+    loadTracksWithMediaCharacteristic$completionHandler$(mediaCharacteristic: _NSString, completionHandler: NobjcObject | null): void;
     metadataForFormat$(format: AVMetadataFormat): _NSArray;
     chapterMetadataGroupsWithTitleLocale$containingItemsWithCommonKeys$(locale: _NSLocale, commonKeys: _NSArray | null): _NSArray;
     chapterMetadataGroupsBestMatchingPreferredLanguages$(preferredLanguages: _NSArray): _NSArray;
-    mediaSelectionGroupForMediaCharacteristic$(mediaCharacteristic: number): _AVMediaSelectionGroup | null;
-    unusedTrackID(): NobjcObject;
+    mediaSelectionGroupForMediaCharacteristic$(mediaCharacteristic: _NSString): _AVMediaSelectionGroup | null;
+    unusedTrackID(): number;
     /** Provides the array of AVCompositionTracks contained by the composition. */
     tracks(): _NSArray;
     /** Indicates the authored size of the visual portion of the composition. */
@@ -49,3 +51,5 @@ export declare class _AVComposition extends _AVAsset {
      */
     URLAssetInitializationOptions(): _NSDictionary;
 }
+export interface _AVComposition extends _NSMutableCopying {
+}

package/dist/AVFoundation/AVCompositionTrack.d.ts

@@ -1,6 +1,7 @@
 import type { _AVAssetTrack } from "./AVAssetTrack.js";
 import type { _AVCompositionTrackSegment } from "./AVCompositionTrackSegment.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { CMTime } from "../structs/CMTime.js";
 import type { AVMetadataFormat } from "./AVMetadataFormat.js";
 import type { AVTrackAssociationType } from "./AVTrackAssociationType.js";
@@ -12,7 +13,7 @@ export declare class _AVCompositionTrack extends _AVAssetTrack {
      * @method segmentForTrackTime: @abstract Supplies the AVCompositionTrackSegment from the segments array with a target timeRange that either contains the specified track time or is the closest to it among the target timeRanges of the track's segments. @param trackTime The trackTime for which an AVCompositionTrackSegment is requested. @result An AVCompositionTrackSegment. @discussion If the trackTime does not map to a sample presentation time (e.g. it's outside the track's timeRange), the segment closest in time to the specified trackTime is returned.
      */
     segmentForTrackTime$(trackTime: CMTime): _AVCompositionTrackSegment | null;
-    hasMediaCharacteristic$(mediaCharacteristic: number): boolean;
+    hasMediaCharacteristic$(mediaCharacteristic: _NSString): boolean;
     samplePresentationTimeForTrackTime$(trackTime: CMTime): CMTime;
     metadataForFormat$(format: AVMetadataFormat): _NSArray;
     associatedTracksOfType$(trackAssociationType: AVTrackAssociationType): _NSArray;

package/dist/AVFoundation/AVCompositionTrackFormatDescriptionReplacement.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 export declare class _AVCompositionTrackFormatDescriptionReplacement extends _NSObject {
     static alloc(): _AVCompositionTrackFormatDescriptionReplacement;
     static new(): _AVCompositionTrackFormatDescriptionReplacement;
@@ -11,3 +12,5 @@ export declare class _AVCompositionTrackFormatDescriptionReplacement extends _NS
      */
     replacementFormatDescription(): NobjcObject;
 }
+export interface _AVCompositionTrackFormatDescriptionReplacement extends _NSSecureCoding {
+}

package/dist/AVFoundation/AVCompositionTrackSegment.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVAssetTrackSegment } from "./AVAssetTrackSegment.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { CMTimeRange } from "../structs/CMTimeRange.js";
@@ -9,7 +8,7 @@ export declare class _AVCompositionTrackSegment extends _AVAssetTrackSegment {
     /**
      * @method compositionTrackSegmentWithURL:trackID:sourceTimeRange:targetTimeRange: @abstract Returns an instance of AVCompositionTrackSegment that presents a portion of a file referenced by URL. @param URL An instance of NSURL that references the container file to be presented by the AVCompositionTrackSegment. @param trackID The track identifier that specifies the track of the container file to be presented by the AVCompositionTrackSegment. @param sourceTimeRange The timeRange of the track of the container file to be presented by the AVCompositionTrackSegment. @param targetTimeRange The timeRange of the composition track during which the AVCompositionTrackSegment is to be presented. @result An instance of AVCompositionTrackSegment. @discussion To specify that the segment be played at the asset's normal rate, set source.duration == target.duration in the timeMapping. Otherwise, the segment will be played at a rate equal to the ratio source.duration / target.duration.
      */
-    static compositionTrackSegmentWithURL$trackID$sourceTimeRange$targetTimeRange$(URL: _NSURL, trackID: NobjcObject, sourceTimeRange: CMTimeRange, targetTimeRange: CMTimeRange): _AVCompositionTrackSegment;
+    static compositionTrackSegmentWithURL$trackID$sourceTimeRange$targetTimeRange$(URL: _NSURL, trackID: number, sourceTimeRange: CMTimeRange, targetTimeRange: CMTimeRange): _AVCompositionTrackSegment;
     /**
      * @method compositionTrackSegmentWithTimeRange: @abstract Returns an instance of AVCompositionTrackSegment that presents an empty track segment. @param timeRange The timeRange of the empty AVCompositionTrackSegment. @result An instance of AVCompositionTrackSegment.
      */
@@ -17,7 +16,7 @@ export declare class _AVCompositionTrackSegment extends _AVAssetTrackSegment {
     /**
      * @method initWithURL:trackID:sourceTimeRange:targetTimeRange: @abstract Initializes an instance of AVCompositionTrackSegment that presents a portion of a file referenced by URL. @param URL An instance of NSURL that references the container file to be presented by the AVCompositionTrackSegment. @param trackID The track identifier that specifies the track of the container file to be presented by the AVCompositionTrackSegment. @param sourceTimeRange The timeRange of the track of the container file to be presented by the AVCompositionTrackSegment. @param targetTimeRange The timeRange of the composition track during which the AVCompositionTrackSegment is to be presented. @result An instance of AVCompositionTrackSegment. @discussion To specify that the segment be played at the asset's normal rate, set source.duration == target.duration in the timeMapping. Otherwise, the segment will be played at a rate equal to the ratio source.duration / target.duration.
      */
-    initWithURL$trackID$sourceTimeRange$targetTimeRange$(URL: _NSURL, trackID: NobjcObject, sourceTimeRange: CMTimeRange, targetTimeRange: CMTimeRange): _AVCompositionTrackSegment;
+    initWithURL$trackID$sourceTimeRange$targetTimeRange$(URL: _NSURL, trackID: number, sourceTimeRange: CMTimeRange, targetTimeRange: CMTimeRange): _AVCompositionTrackSegment;
     /**
      * @method initWithTimeRange: @abstract Initializes an instance of AVCompositionTrackSegment that presents an empty track segment. @param timeRange The timeRange of the empty AVCompositionTrackSegment. @result An instance of AVCompositionTrackSegment.
      */
@@ -33,5 +32,5 @@ export declare class _AVCompositionTrackSegment extends _AVAssetTrackSegment {
     /**
      * indicates the track of the container file of the media presented by the AVCompositionTrackSegment
      */
-    sourceTrackID(): NobjcObject;
+    sourceTrackID(): number;
 }