objcjs-types 0.1.0 → 0.2.1

package/dist/AVFoundation/AVCaptureAudioFileOutput.d.ts

@@ -2,6 +2,7 @@ import type { _AVCaptureFileOutput } from "./AVCaptureFileOutput.js";
 import type { _AVCaptureFileOutputRecordingDelegate } from "./AVCaptureFileOutputRecordingDelegate.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 export declare class _AVCaptureAudioFileOutput extends _AVCaptureFileOutput {
     static alloc(): _AVCaptureAudioFileOutput;
@@ -14,7 +15,7 @@ export declare class _AVCaptureAudioFileOutput extends _AVCaptureFileOutput {
     /**
      * @method startRecordingToOutputFileURL:outputFileType:recordingDelegate: @abstract Tells the receiver to start recording to a new file of the specified format, and specifies a delegate that will be notified when recording is finished. @param outputFileURL An NSURL object containing the URL of the output file. This method throws an NSInvalidArgumentException if the URL is not a valid file URL. @param fileType A UTI indicating the format of the file to be written. @param delegate An object conforming to the AVCaptureFileOutputRecordingDelegate protocol. Clients must specify a delegate so that they can be notified when recording to the given URL is finished. @discussion The method sets the file URL to which the receiver is currently writing output media. If a file at the given URL already exists when capturing starts, recording to the new file will fail. The fileType argument is a UTI corresponding to the audio file format that should be written. UTIs for common audio file types are declared in AVMediaFormat.h. Clients need not call stopRecording before calling this method while another recording is in progress. If this method is invoked while an existing output file was already being recorded, no media samples will be discarded between the old file and the new file. When recording is stopped either by calling stopRecording, by changing files using this method, or because of an error, the remaining data that needs to be included to the file will be written in the background. Therefore, clients must specify a delegate that will be notified when all data has been written to the file using the captureOutput:didFinishRecordingToOutputFileAtURL:fromConnections:error: method. The recording delegate can also optionally implement methods that inform it when data starts being written, when recording is paused and resumed, and when recording is about to be finished. On macOS, if this method is called within the captureOutput:didOutputSampleBuffer:fromConnection: delegate method, the first samples written to the new file are guaranteed to be those contained in the sample buffer passed to that method.
      */
-    startRecordingToOutputFileURL$outputFileType$recordingDelegate$(outputFileURL: _NSURL, fileType: number, delegate: _AVCaptureFileOutputRecordingDelegate): void;
+    startRecordingToOutputFileURL$outputFileType$recordingDelegate$(outputFileURL: _NSURL, fileType: _NSString, delegate: _AVCaptureFileOutputRecordingDelegate): void;
     /**
      * @property metadata @abstract A collection of metadata to be written to the receiver's output files. @discussion 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. Only ID3 v2.2, v2.3, or v2.4 style metadata items are supported.
      */

package/dist/AVFoundation/AVCaptureDataOutputSynchronizer.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 { _AVCaptureDataOutputSynchronizerDelegate } from "./AVCaptureDataOutputSynchronizerDelegate.js";
@@ -13,7 +12,7 @@ export declare class _AVCaptureDataOutputSynchronizer extends _NSObject {
     /**
      * @method setDelegate:queue: @abstract Sets the receiver's delegate that will accept synchronized data and the dispatch queue on which the delegate will be called. @param delegate An object conforming to the AVCaptureDataOutputSynchronizerDelegate protocol that will receive synchronized data from the provided data outputs. @param delegateCallbackQueue A dispatch queue on which all AVCaptureDataOutputSynchronizerDelegate methods will be called. @discussion AVCaptureDataOutputSynchronizer gathers data from its dataOutputs, and when it determines that all data has been received for a given timestamp, it calls the specified delegate on the specified delegateCallbackQueue. AVCaptureDataOutputSynchronizer overrides all the data outputs' delegates and callbacks. Data outputs under the control of AVCaptureDataOutputSynchronizer do not fire delegate callbacks. Delegate callbacks are restored to individual data outputs when you call this method with nil as your delegate and NULL as your delegateCallbackQueue. A serial dispatch queue must be used to guarantee that synchronized data will be delivered in order. The delegateCallbackQueue parameter may not be NULL, except when setting the delegate to nil otherwise -setDelegate:queue: throws an NSInvalidArgumentException.
      */
-    setDelegate$queue$(delegate: _AVCaptureDataOutputSynchronizerDelegate | null, delegateCallbackQueue: NobjcObject): void;
+    setDelegate$queue$(delegate: _AVCaptureDataOutputSynchronizerDelegate | null, delegateCallbackQueue: _NSObject | null): void;
     /**
      * @property dataOutputs @abstract The data outputs provided in the initializer method.
      */
@@ -25,5 +24,5 @@ export declare class _AVCaptureDataOutputSynchronizer extends _NSObject {
     /**
      * @property delegateCallbackQueue @abstract The dispatch queue on which all AVCaptureDataOutputSynchronizerDelegate methods will be called. @discussion The value of this property is a dispatch_queue_t. The queue is set using the -setDelegate:queue: method.
      */
-    delegateCallbackQueue(): NobjcObject;
+    delegateCallbackQueue(): _NSObject | null;
 }

package/dist/AVFoundation/AVCaptureDepthDataOutput.d.ts

@@ -1,6 +1,6 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCaptureDepthDataOutputDelegate } from "./AVCaptureDepthDataOutputDelegate.js";
 import type { _AVCaptureOutput } from "./AVCaptureOutput.js";
+import type { _NSObject } from "../Foundation/NSObject.js";
 export declare class _AVCaptureDepthDataOutput extends _AVCaptureOutput {
     static alloc(): _AVCaptureDepthDataOutput;
     static new(): _AVCaptureDepthDataOutput;
@@ -8,7 +8,7 @@ export declare class _AVCaptureDepthDataOutput extends _AVCaptureOutput {
     /**
      * @method setDelegate:queue: @abstract Sets the receiver's delegate that receives captured depth data and the dispatch queue on which the delegate is called. @param delegate An object conforming to the AVCaptureDepthDataOutputDelegate protocol that receives depth data in a streaming fashion. @param callbackQueue A dispatch queue on which all delegate methods are called. @discussion The depth data output vends captured depth data to its delegate using the methods specified in the AVCaptureDepthOutputDelegate protocol. All delegate methods are called on the specified dispatch queue. If the callback queue is blocked when new depth data is captured, that depth data is automatically dropped at a time determined by the value of the alwaysDiscardsLateDepthData property. This allows clients to process existing depth data 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 depth data. Clients who need to minimize the chances of depth data being dropped should provide a dedicated queue and not share it with other data outputs. Processing of depth data may be deferred to another queue, but beware that the depth data pixel buffer maps may come from a finite buffer pool, which may be starved if your deferred processing fails to keep up. A serial dispatch queue must be used to guarantee that depth data will be delivered in order. The callbackQueue parameter may not be NULL, except when setting the delegate to nil otherwise -setDelegate:callbackQueue: throws an NSInvalidArgumentException.
      */
-    setDelegate$callbackQueue$(delegate: _AVCaptureDepthDataOutputDelegate | null, callbackQueue: NobjcObject): void;
+    setDelegate$callbackQueue$(delegate: _AVCaptureDepthDataOutputDelegate | null, callbackQueue: _NSObject | null): void;
     /**
      * @property delegate @abstract The receiver's delegate. @discussion The value of this property is an object conforming to the AVCaptureDepthDataOutputDelegate protocol that receives depth data as it is captured. The delegate is set using the setDelegate:callbackQueue: method.
      */
@@ -16,7 +16,7 @@ export declare class _AVCaptureDepthDataOutput extends _AVCaptureOutput {
     /**
      * @property delegateCallbackQueue @abstract The dispatch queue on which all delegate methods are called. @discussion The value of this property is a dispatch_queue_t. The queue is set using the setDelegate:queue: method.
      */
-    delegateCallbackQueue(): NobjcObject;
+    delegateCallbackQueue(): _NSObject | null;
     /**
      * @property alwaysDiscardsLateDepthData @abstract Specifies whether the receiver should always discard any depth data that is not processed before the next depth data is captured. @discussion When the value of this property is YES, the receiver will immediately discard depth data that are captured while the delegateCallbackQueue is blocked. When the value of this property is NO, delegates will be allowed more time to process old depth data before new depth data are discarded, but application memory usage may increase as a result. The default value is YES.
      */

package/dist/AVFoundation/AVCaptureDeskViewApplication.d.ts

@@ -8,9 +8,9 @@ export declare class _AVCaptureDeskViewApplication extends _NSObject {
     /**
      * @method presentWithCompletionHandler: @abstract Presents the Desk View application to the user with no launch configuration. @param completionHandler A block to be called once the Desk View application has been completely launched (or brought to the foreground). @discussion This method allows you to programmatically launch the Desk View application from your own application UI. If the Desk View application is already running, this method brings it to the front. If the Desk View application is minimized in the Dock, this method un-minimizes it and brings it to the front.
      */
-    presentWithCompletionHandler$(completionHandler: NobjcObject): void;
+    presentWithCompletionHandler$(completionHandler: NobjcObject | null): void;
     /**
      * @method presentWithLaunchConfiguration:completionHandler: @abstract Presents the Desk View application to the user. @param launchConfiguration Launch configuration governing how the Desk View application will be presented. @param completionHandler A block to be called once the Desk View application has been completely launched (or brought to the foreground). Optionally, this completionHandler may fire later, once the user has completed set up mode (see AVCaptureDeskViewApplicationLaunchConfiguration.requiresSetUpModeCompletion). @discussion This method allows you to programmatically launch the Desk View application from your own application UI. If the Desk View application is already running, this method brings it to the front. If the Desk View application is minimized in the Dock, this method un-minimizes it and brings it to the front.
      */
-    presentWithLaunchConfiguration$completionHandler$(launchConfiguration: _AVCaptureDeskViewApplicationLaunchConfiguration, completionHandler: NobjcObject): void;
+    presentWithLaunchConfiguration$completionHandler$(launchConfiguration: _AVCaptureDeskViewApplicationLaunchConfiguration, completionHandler: NobjcObject | null): void;
 }

package/dist/AVFoundation/AVCaptureDevice.d.ts

@@ -50,11 +50,11 @@ export declare class _AVCaptureDevice extends _NSObject {
      * @method devicesWithMediaType: @abstract Returns an array of devices currently available for use as sources of media with the given media type. @param mediaType The media type, such as AVMediaTypeVideo, AVMediaTypeAudio, or AVMediaTypeMuxed, supported by each returned device. @result An NSArray of AVCaptureDevice instances for each available device. @discussion This method returns an array of AVCaptureDevice instances for input devices currently connected and available for capture that provide media of the given type. Media type constants are defined in AVMediaFormat.h. The returned array contains all devices that are available at the time the method is called. Applications should observe AVCaptureDeviceWasConnectedNotification and AVCaptureDeviceWasDisconnectedNotification to be notified when the list of available devices has changed.
      * @deprecated Use AVCaptureDeviceDiscoverySession instead.
      */
-    static devicesWithMediaType$(mediaType: number): _NSArray;
+    static devicesWithMediaType$(mediaType: _NSString): _NSArray;
     /**
      * @method defaultDeviceWithMediaType: @abstract Returns an AVCaptureDevice instance for the default device of the given media type. @param mediaType The media type, such as AVMediaTypeVideo, AVMediaTypeAudio, or AVMediaTypeMuxed, supported by the returned device. @result The default device with the given media type, or nil if no device with that media type exists. @discussion This method returns the default device of the given media type currently available on the system. For example, for AVMediaTypeVideo, this method will return the built in camera that is primarily used for capture and recording. Media type constants are defined in AVMediaFormat.h.
      */
-    static defaultDeviceWithMediaType$(mediaType: number): _AVCaptureDevice | null;
+    static defaultDeviceWithMediaType$(mediaType: _NSString): _AVCaptureDevice | null;
     /**
      * @method deviceWithUniqueID: @abstract Returns an AVCaptureDevice instance with the given unique ID. @param deviceUniqueID The unique ID of the device instance to be returned. @result An AVCaptureDevice instance with the given unique ID, or nil if no device with that unique ID is available. @discussion Every available capture device has a unique ID that persists on one system across device connections and disconnections, application restarts, and reboots of the system itself. This method can be used to recall or track the status of a specific device whose unique ID has previously been saved.
      */
@@ -62,15 +62,15 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * @method defaultDeviceWithDeviceType:mediaType:position: @abstract Returns an AVCaptureDevice instance for the default device of the given device type, media type, and position. @param deviceType The device type supported by the returned device. It must be a valid AVCaptureDeviceType. @param mediaType The media type, such as AVMediaTypeVideo, AVMediaTypeAudio, or AVMediaTypeMuxed, supported by the returned device. Pass nil to consider devices with any media type. @param position The position supported by the returned device. Pass AVCaptureDevicePositionUnspecified to consider devices with any position. @result The default device with the given device type, media type and position or nil if no device with that media type exists and nil otherwise. @discussion This method returns the default device of the given combination of device type, media type, and position currently available on the system.
      */
-    static defaultDeviceWithDeviceType$mediaType$position$(deviceType: AVCaptureDeviceType, mediaType: number | null, position: AVCaptureDevicePosition): _AVCaptureDevice | null;
+    static defaultDeviceWithDeviceType$mediaType$position$(deviceType: AVCaptureDeviceType, mediaType: _NSString | null, position: AVCaptureDevicePosition): _AVCaptureDevice | null;
     /**
      * @method authorizationStatusForMediaType: @abstract Returns the client's authorization status for accessing the underlying hardware that supports a given media type. @param mediaType The media type, either AVMediaTypeVideo or AVMediaTypeAudio @result The authorization status of the client @discussion This method returns the AVAuthorizationStatus of the client for accessing the underlying hardware supporting the media type. Media type constants are defined in AVMediaFormat.h. If any media type other than AVMediaTypeVideo or AVMediaTypeAudio is supplied, an NSInvalidArgumentException will be thrown. If the status is AVAuthorizationStatusNotDetermined, you may use the +requestAccessForMediaType:completionHandler: method to request access by prompting the user.
      */
-    static authorizationStatusForMediaType$(mediaType: number): AVAuthorizationStatus;
+    static authorizationStatusForMediaType$(mediaType: _NSString): AVAuthorizationStatus;
     /**
      * @method requestAccessForMediaType:completionHandler: @abstract Requests access to the underlying hardware for the media type, showing a dialog to the user if necessary. @param mediaType The media type, either AVMediaTypeVideo or AVMediaTypeAudio @param handler A block called with the result of requesting access @discussion Use this function to request access to the hardware for a given media type. Media type constants are defined in AVMediaFormat.h. If any media type other than AVMediaTypeVideo or AVMediaTypeAudio is supplied, an NSInvalidArgumentException will be thrown. This call will not block while the user is being asked for access, allowing the client to continue running. Until access has been granted, any AVCaptureDevices for the media type will vend silent audio samples or black video frames. The user is only asked for permission the first time the client requests access. Later calls use the permission granted by the user. Note that the authorization dialog will automatically be shown if the status is AVAuthorizationStatusNotDetermined when creating an AVCaptureDeviceInput. Invoking this method with AVMediaTypeAudio is equivalent to calling -[AVAudioSession requestRecordPermission:]. The completion handler is called on an arbitrary dispatch queue. It is the client's responsibility to ensure that any UIKit-related updates are called on the main queue or main thread as a result.
      */
-    static requestAccessForMediaType$completionHandler$(mediaType: number, handler: NobjcObject): void;
+    static requestAccessForMediaType$completionHandler$(mediaType: _NSString, handler: NobjcObject): void;
     /**
      * @method extrinsicMatrixFromDevice:toDevice: @abstract An NSData containing the relative extrinsic matrix from one AVCaptureDevice to another. @param fromDevice The AVCaptureDevice to use as the source. Must be non nil or an NSInvalidArgumentException is thrown. @param toDevice The AVCaptureDevice to use as the destination. Must be non nil or an NSInvalidArgumentException is thrown. @discussion The extrinsic matrix consists of a unitless 3x3 rotation matrix (R) on the left and a translation (t) 3x1 column vector on the right. The translation vector's units are millimeters. The extrinsics of the "toDevice" camera are expressed with respect to a reference camera "fromDevice". If X_from is a 3D point in "fromCamera"'s coordinate system, then it can be projected into "toCamera"'s coordinate system with X_to = [R | t] * X_from. Note that a matrix_float4x3 matrix is column major with 3 rows and 4 columns. The extrinsicMatrix is only provided for physical cameras for which factory calibrations exist. Virtual device cameras return nil. / \ / \ | r1,1 r1,2 r1,3 | t1 | |R|t| = | r2,1 r2,2 r2,3 | t2 | \ / | r3,1 r3,2 r3,3 | t3 | \ / Note that if you enable video stabilization (see AVCaptureConnection.preferredVideoStabilizationMode), the pixels in stabilized video frames no longer match the relative extrinsicMatrix from one device to another due to warping. The extrinsicMatrix and camera intrinsics should only be used when video stabilization is disabled.
      */
@@ -137,11 +137,11 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * @method hasMediaType: @abstract Returns whether the receiver provides media with the given media type. @param mediaType A media type, such as AVMediaTypeVideo, AVMediaTypeAudio, or AVMediaTypeMuxed. @result YES if the device outputs the given media type, NO otherwise. @discussion Media type constants are defined in AVMediaFormat.h.
      */
-    hasMediaType$(mediaType: number): boolean;
+    hasMediaType$(mediaType: _NSString): boolean;
     /**
      * @method lockForConfiguration: @abstract Requests exclusive access to configure device hardware properties. @param outError On return, if the device could not be locked, points to an NSError describing why the failure occurred. @result A BOOL indicating whether the device was successfully locked for configuration. @discussion In order to set hardware properties on an AVCaptureDevice, such as focusMode and exposureMode, clients must first acquire a lock on the device. Clients should only hold the device lock if they require settable device properties to remain unchanged. Holding the device lock unnecessarily may degrade capture quality in other applications sharing the device.
      */
-    lockForConfiguration$(outError: NobjcObject): boolean;
+    lockForConfiguration$(outError: NobjcObject | null): boolean;
     /**
      * @method unlockForConfiguration @abstract Release exclusive control over device hardware properties. @discussion This method should be called to match an invocation of lockForConfiguration: when an application no longer needs to keep device hardware properties from changing automatically.
      */
@@ -166,7 +166,7 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * @method setTorchModeOnWithLevel:error: @abstract Sets the current mode of the receiver's torch to AVCaptureTorchModeOn at the specified level. @discussion This method sets the torch mode to AVCaptureTorchModeOn at a specified level. torchLevel must be a value between 0 and 1, or the special value AVCaptureMaxAvailableTorchLevel. The specified value may not be available if the iOS device is too hot. This method throws an NSInvalidArgumentException if set to an unsupported level. If the specified level is valid, but unavailable, the method returns NO with AVErrorTorchLevelUnavailable. -setTorchModeOnWithLevel:error: throws an NSGenericException if called without first obtaining exclusive access to the receiver using lockForConfiguration:. Clients can observe automatic changes to the receiver's torchMode by key value observing the torchMode property.
      */
-    setTorchModeOnWithLevel$error$(torchLevel: number, outError: NobjcObject): boolean;
+    setTorchModeOnWithLevel$error$(torchLevel: number, outError: NobjcObject | null): boolean;
     /**
      * @method isFocusModeSupported: @abstract Returns whether the receiver supports the given focus mode. @param focusMode An AVCaptureFocusMode to be checked. @result YES if the receiver supports the given focus mode, NO otherwise. @discussion The receiver's focusMode property can only be set to a certain mode if this method returns YES for that mode.
      */
@@ -178,7 +178,7 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * @method setFocusModeLockedWithLensPosition:completionHandler: @abstract Sets focusMode to AVCaptureFocusModeLocked and locks lensPosition at an explicit value. @param lensPosition The lens position, as described in the documentation for the lensPosition property. A value of AVCaptureLensPositionCurrent can be used to indicate that the caller does not wish to specify a value for lensPosition. @param handler A block to be called when lensPosition has been set to the value specified and focusMode is set to AVCaptureFocusModeLocked. If setFocusModeLockedWithLensPosition:completionHandler: is called multiple times, the completion handlers will be called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the `AVCaptureSession/synchronizationClock` prior to comparison with the timestamps of buffers delivered via an AVCaptureVideoDataOutput. The client may pass nil for the handler parameter if knowledge of the operation's completion is not required. @discussion This is the only way of setting lensPosition. This method throws an NSRangeException if lensPosition is set to an unsupported level. This method throws an NSGenericException if called without first obtaining exclusive access to the receiver using lockForConfiguration:.
      */
-    setFocusModeLockedWithLensPosition$completionHandler$(lensPosition: number, handler: NobjcObject): void;
+    setFocusModeLockedWithLensPosition$completionHandler$(lensPosition: number, handler: NobjcObject | null): void;
     /**
      * Focus on and start tracking a detected object. - Parameter detectedObjectID: The ID of the detected object. - Parameter focusMode: Specify whether to focus strongly or weakly.
      */
@@ -202,11 +202,11 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * @method setExposureModeCustomWithDuration:ISO:completionHandler: @abstract Sets exposureMode to AVCaptureExposureModeCustom and locks exposureDuration and ISO at explicit values. @param duration The exposure duration, as described in the documentation for the exposureDuration property. A value of AVCaptureExposureDurationCurrent can be used to indicate that the caller does not wish to specify a value for exposureDuration. Note that changes to this property may result in changes to activeVideoMinFrameDuration and/or activeVideoMaxFrameDuration. @param ISO The exposure ISO value, as described in the documentation for the ISO property. A value of AVCaptureISOCurrent can be used to indicate that the caller does not wish to specify a value for ISO. @param handler A block to be called when both exposureDuration and ISO have been set to the values specified and exposureMode is set to AVCaptureExposureModeCustom. If setExposureModeCustomWithDuration:ISO:completionHandler: is called multiple times, the completion handlers will be called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the `AVCaptureSession/synchronizationClock` prior to comparison with the timestamps of buffers delivered via an AVCaptureVideoDataOutput. The client may pass nil for the handler parameter if knowledge of the operation's completion is not required. @discussion This is the only way of setting exposureDuration and ISO. This method throws an NSRangeException if either exposureDuration or ISO is set to an unsupported level. This method throws an NSGenericException if called without first obtaining exclusive access to the receiver using lockForConfiguration:. When using AVCapturePhotoOutput to capture photos, note that the photoQualityPrioritization property of AVCapturePhotoSettings defaults to AVCapturePhotoQualityPrioritizationBalanced, which allows photo capture to temporarily override the capture device's ISO and exposureDuration values if the scene is dark enough to warrant some form of multi-image fusion to improve quality. To ensure that the receiver's ISO and exposureDuration values are honored while in AVCaptureExposureModeCustom or AVCaptureExposureModeLocked, you must set your AVCapturePhotoSettings.photoQualityPrioritization property to AVCapturePhotoQualityPrioritizationSpeed. The same rule applies if you use the deprecated AVCapturePhotoSettings.autoStillImageStabilizationEnabled property or AVCaptureStillImageOutput.automaticallyEnablesStillImageStabilizationWhenAvailable property. You must set them to NO to preserve your custom or locked exposure settings.
      */
-    setExposureModeCustomWithDuration$ISO$completionHandler$(duration: CMTime, ISO: number, handler: NobjcObject): void;
+    setExposureModeCustomWithDuration$ISO$completionHandler$(duration: CMTime, ISO: number, handler: NobjcObject | null): void;
     /**
      * @method setExposureTargetBias:completionHandler: @abstract Sets the bias to be applied to the target exposure value. @param bias The bias to be applied to the exposure target value, as described in the documentation for the exposureTargetBias property. @param handler A block to be called when exposureTargetBias has been set to the value specified. If setExposureTargetBias:completionHandler: is called multiple times, the completion handlers will be called in FIFO order. The block receives a timestamp which matches that of the first buffer to which the setting has been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the `AVCaptureSession/synchronizationClock` prior to comparison with the timestamps of buffers delivered via an AVCaptureVideoDataOutput. The client may pass nil for the handler parameter if knowledge of the operation's completion is not required. @discussion This is the only way of setting exposureTargetBias. This method throws an NSRangeException if exposureTargetBias is set to an unsupported level. This method throws an NSGenericException if called without first obtaining exclusive access to the receiver using lockForConfiguration:.
      */
-    setExposureTargetBias$completionHandler$(bias: number, handler: NobjcObject): void;
+    setExposureTargetBias$completionHandler$(bias: number, handler: NobjcObject | null): void;
     /**
      * @method isWhiteBalanceModeSupported: @abstract Returns whether the receiver supports the given white balance mode. @param whiteBalanceMode An AVCaptureWhiteBalanceMode to be checked. @result YES if the receiver supports the given white balance mode, NO otherwise. @discussion The receiver's whiteBalanceMode property can only be set to a certain mode if this method returns YES for that mode.
      */
@@ -214,11 +214,11 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * Sets white balance to locked mode with explicit temperature and tint values. - Parameter whiteBalanceTemperatureAndTintValues: The white balance temperature and tint values, as computed from ``temperatureAndTintValuesForDeviceWhiteBalanceGains:`` method, ``AVCaptureWhiteBalanceTemperatureAndTintValues`` presets or manual input. - Parameter handler: A block to be called when white balance values have been set to the values specified and ``whiteBalanceMode`` is set to ``AVCaptureWhiteBalanceModeLocked``. If ``setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues:completionHandler:`` is called multiple times, the completion handlers are called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the ``AVCaptureSession/synchronizationClock`` prior to comparison with the timestamps of buffers delivered via an ``AVCaptureVideoDataOutput``. This parameter may be `nil` if synchronization is not required. This method takes a ``AVCaptureWhiteBalanceTemperatureAndTintValues`` struct and applies the appropriate ``AVCaptureWhiteBalanceGains``. This method throws an `NSRangeException` if any of the values are set to an unsupported level. This method throws an `NSGenericException` if called without first obtaining exclusive access to the device using ``AVCaptureDevice/lockForConfiguration:``.
      */
-    setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues$completionHandler$(whiteBalanceTemperatureAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues, handler: NobjcObject): void;
+    setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues$completionHandler$(whiteBalanceTemperatureAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues, handler: NobjcObject | null): void;
     /**
      * @method setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains:completionHandler: @abstract Sets white balance to locked mode with explicit deviceWhiteBalanceGains values. @param whiteBalanceGains The white balance gain values, as described in the documentation for the deviceWhiteBalanceGains property. A value of AVCaptureWhiteBalanceGainsCurrent can be used to indicate that the caller does not wish to specify a value for deviceWhiteBalanceGains. @param handler A block to be called when white balance gains have been set to the values specified and whiteBalanceMode is set to AVCaptureWhiteBalanceModeLocked. If setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains:completionHandler: is called multiple times, the completion handlers will be called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the `AVCaptureSession/synchronizationClock` prior to comparison with the timestamps of buffers delivered via an AVCaptureVideoDataOutput. This parameter may be nil if synchronization is not required. @discussion Gain values are normalized to the minimum channel value to avoid brightness changes (e.g. R:2 G:2 B:4 will be normalized to R:1 G:1 B:2). For each channel in the whiteBalanceGains struct, only values between 1.0 and maxWhiteBalanceGain after nomalization are supported. This method throws an NSRangeException if any of the whiteBalanceGains are set to an unsupported level. This method throws an NSGenericException if called without first obtaining exclusive access to the receiver using lockForConfiguration:.
      */
-    setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains$completionHandler$(whiteBalanceGains: AVCaptureWhiteBalanceGains, handler: NobjcObject): void;
+    setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains$completionHandler$(whiteBalanceGains: AVCaptureWhiteBalanceGains, handler: NobjcObject | null): void;
     /**
      * @method chromaticityValuesForDeviceWhiteBalanceGains: @abstract Converts device-specific white balance RGB gain values to device-independent chromaticity values. @param whiteBalanceGains White balance gain values, as described in the documentation for the deviceWhiteBalanceGains property. A value of AVCaptureWhiteBalanceGainsCurrent may not be used in this function. @result A fully populated AVCaptureWhiteBalanceChromaticityValues structure containing device-independent values. @discussion This method may be called on the receiver to convert device-specific white balance RGB gain values to device-independent chromaticity (little x, little y) values. For each channel in the whiteBalanceGains struct, only values between 1.0 and -maxWhiteBalanceGain are supported. This method throws an NSRangeException if any of the whiteBalanceGains are set to unsupported values.
      */
@@ -254,7 +254,7 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * Updates the dynamic aspect ratio of the device. - Parameter dynamicAspectRatio: The new ``AVCaptureAspectRatio`` the device should output. - Parameter handler: A block called by the device when `dynamicAspectRatio` is set to the value specified. If you call ``setDynamicAspectRatio:completionHandler:`` multiple times, the completion handlers are called in FIFO order. The block receives a timestamp which matches that of the first buffer to which all settings have been applied. Note that the timestamp is synchronized to the device clock, and thus must be converted to the ``AVCaptureSession/synchronizationClock`` prior to comparison with the timestamps of buffers delivered via an ``AVCaptureVideoDataOutput``. You may pass `nil` for the `handler` parameter if you do not need to know when the operation completes. This is the only way of setting ``dynamicAspectRatio``. This method throws an `NSInvalidArgumentException` if `dynamicAspectRatio` is not a supported aspect ratio found in the device's activeFormat's ``AVCaptureDeviceFormat/supportedDynamicAspectRatios``. This method throws an `NSGenericException` if you call it without first obtaining exclusive access to the device using ``AVCaptureDevice/lockForConfiguration:``.
      */
-    setDynamicAspectRatio$completionHandler$(dynamicAspectRatio: AVCaptureAspectRatio, handler: NobjcObject): void;
+    setDynamicAspectRatio$completionHandler$(dynamicAspectRatio: AVCaptureAspectRatio, handler: NobjcObject | null): void;
     /**
      * Specify whether to enable camera lens smudge detection, and the interval time between each run of detections. - Parameter cameraLensSmudgeDetectionEnabled: Specify whether camera lens smudge detection should be enabled. - Parameter detectionInterval: The detection running interval if detection is enabled. Each run of detection processes frames over a short period, and produces one detection result. Use `detectionInterval` to specify the interval time between each run of detections. For example, when ``cameraLensSmudgeDetectionEnabled`` is set to `true` and `detectionInterval` is set to 1 minute, detection runs once per minute, and updates ``AVCaptureCameraLensSmudgeDetectionStatus``. If `detectionInterval` is set to ``kCMTimeInvalid``, detection runs only once after the session starts. If `detectionInterval` is set to ``kCMTimeZero``, detection runs continuously. ``AVCaptureDevice`` throws an `NSInvalidArgumentException` if the ``AVCaptureDeviceFormat/cameraLensSmudgeDetectionSupported`` property on the current active format returns `false`. Enabling detection requires a lengthy reconfiguration of the capture render pipeline, so you should enable detection before calling ``AVCaptureSession/startRunning`` or within ``AVCaptureSession/beginConfiguration`` and ``AVCaptureSession/commitConfiguration`` while running.
      */

package/dist/AVFoundation/AVCaptureDeviceDiscoverySession.d.ts

@@ -1,6 +1,6 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { AVCaptureDevicePosition } from "./AVCaptureDevicePosition.js";
 export declare class _AVCaptureDeviceDiscoverySession extends _NSObject {
     static alloc(): _AVCaptureDeviceDiscoverySession;
@@ -9,7 +9,7 @@ export declare class _AVCaptureDeviceDiscoverySession extends _NSObject {
     /**
      * @method discoverySessionWithDeviceTypes: @abstract Returns an AVCaptureDeviceDiscoverySession instance for the given device types, media type, and position. @param deviceTypes An array specifying the device types to include in the list of discovered devices. @param mediaType The media type, such as AVMediaTypeVideo, AVMediaTypeAudio, or AVMediaTypeMuxed, to include in the list of discovered devices. Pass nil to search for devices with any media type. @param position The position to include in the list of discovered devices. Pass AVCaptureDevicePositionUnspecified to search for devices with any position. @result The AVCaptureDeviceDiscoverySession from which the list of devices can be obtained. @discussion The list of device types is mandatory. This is used to make sure that clients only get access to devices of types they expect. This prevents new device types from automatically being included in the list of devices.
      */
-    static discoverySessionWithDeviceTypes$mediaType$position$(deviceTypes: _NSArray, mediaType: number | null, position: AVCaptureDevicePosition): _AVCaptureDeviceDiscoverySession;
+    static discoverySessionWithDeviceTypes$mediaType$position$(deviceTypes: _NSArray, mediaType: _NSString | null, position: AVCaptureDevicePosition): _AVCaptureDeviceDiscoverySession;
     /**
      * @property devices @abstract The list of devices that comply to the search criteria specified on the discovery session. @discussion The returned array contains only devices that are available at the time the method is called. Applications can key-value observe this property to be notified when the list of available devices has changed. For apps linked against iOS 10, the devices returned are unsorted. For apps linked against iOS 11 or later, the devices are sorted by AVCaptureDeviceType, matching the order specified in the deviceTypes parameter of +[AVCaptureDeviceDiscoverySession discoverySessionWithDeviceTypes:mediaType:position:]. If a position of AVCaptureDevicePositionUnspecified is specified, the results are further ordered by position in the AVCaptureDevicePosition enum. Starting in Mac Catalyst 14.0, clients can key value observe the value of this property to be notified when the devices change.
      */
@@ -17,5 +17,5 @@ export declare class _AVCaptureDeviceDiscoverySession extends _NSObject {
     /**
      * @property supportedMultiCamDeviceSets @abstract An array of sets of AVCaptureDevices that are allowed to be used simultaneously in an AVCaptureMultiCamSession. @discussion When using an AVCaptureMultiCamSession, multiple cameras may be used as device inputs to the session, so long as they are included in one of the supportedMultiCamDeviceSets. Starting in Mac Catalyst 14.0, clients can key value observe the value of this property to be notified when the device sets change.
      */
-    supportedMultiCamDeviceSets(): NobjcObject;
+    supportedMultiCamDeviceSets(): _NSArray;
 }

package/dist/AVFoundation/AVCaptureDeviceFormat.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVExposureBiasRange } from "./AVExposureBiasRange.js";
 import type { _AVFrameRateRange } from "./AVFrameRateRange.js";
 import type { _AVZoomRange } from "./AVZoomRange.js";
@@ -24,7 +25,7 @@ export declare class _AVCaptureDeviceFormat extends _NSObject {
     /**
      * @property mediaType @abstract An NSString describing the media type of an AVCaptureDevice active or supported format. @discussion Supported mediaTypes are listed in AVMediaFormat.h. This is a read-only property. The caller assumes no ownership of the returned value and should not CFRelease it.
      */
-    mediaType(): number;
+    mediaType(): _NSString;
     /**
      * @property formatDescription @abstract A CMFormatDescription describing an AVCaptureDevice active or supported format. @discussion A CMFormatDescription describing an AVCaptureDevice active or supported format. This is a read-only property. The caller assumes no ownership of the returned value and should not CFRelease it.
      */

package/dist/AVFoundation/AVCaptureDeviceInput.d.ts

@@ -4,6 +4,7 @@ import type { _AVCaptureInput } from "./AVCaptureInput.js";
 import type { _AVExternalSyncDevice } from "./AVExternalSyncDevice.js";
 import type { _AVExternalSyncDeviceDelegate } from "./AVExternalSyncDeviceDelegate.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { CMTime } from "../structs/CMTime.js";
 import type { AVCaptureDevicePosition } from "./AVCaptureDevicePosition.js";
 import type { AVCaptureDeviceType } from "./AVCaptureDeviceType.js";
@@ -15,15 +16,15 @@ export declare class _AVCaptureDeviceInput extends _AVCaptureInput {
     /**
      * Returns an AVCaptureDeviceInput instance that provides media data from the given device. An AVCaptureDevice instance to be used for capture. On return, if the given device cannot be used for capture, points to an NSError describing the problem. An AVCaptureDeviceInput instance that provides data from the given device, or nil, if the device could not be used for capture. This method returns an instance of AVCaptureDeviceInput that can be used to capture data from an AVCaptureDevice in an AVCaptureSession. This method attempts to open the device for capture, taking exclusive control of it if necessary. If the device cannot be opened because it is no longer available or because it is in use, for example, this method returns nil, and the optional outError parameter points to an NSError describing the problem.
      */
-    static deviceInputWithDevice$error$(device: _AVCaptureDevice, outError: NobjcObject): _AVCaptureDeviceInput | null;
+    static deviceInputWithDevice$error$(device: _AVCaptureDevice, outError: NobjcObject | null): _AVCaptureDeviceInput | null;
     /**
      * Creates an AVCaptureDeviceInput instance that provides media data from the given device. An AVCaptureDevice instance to be used for capture. On return, if the given device cannot be used for capture, points to an NSError describing the problem. An AVCaptureDeviceInput instance that provides data from the given device, or nil, if the device could not be used for capture. This method creates an instance of AVCaptureDeviceInput that can be used to capture data from an AVCaptureDevice in an AVCaptureSession. This method attempts to open the device for capture, taking exclusive control of it if necessary. If the device cannot be opened because it is no longer available or because it is in use, for example, this method returns nil, and the optional outError parameter points to an NSError describing the problem.
      */
-    initWithDevice$error$(device: _AVCaptureDevice, outError: NobjcObject): _AVCaptureDeviceInput | null;
+    initWithDevice$error$(device: _AVCaptureDevice, outError: NobjcObject | null): _AVCaptureDeviceInput | null;
     /**
      * An accessor method used to retrieve a virtual device's constituent device ports for use in an AVCaptureMultiCamSession. The AVMediaType of the port for which you're searching, or nil if all media types should be considered. The AVCaptureDeviceType of the port for which you're searching, or nil if source device type is irrelevant. The AVCaptureDevicePosition of the port for which you're searching. AVCaptureDevicePositionUnspecified is germane to audio devices, indicating omnidirectional audio. For other types of capture devices (e.g. cameras), AVCaptureDevicePositionUnspecified means all positions should be considered in the search. An array of AVCaptureInputPorts satisfying the search criteria, or an empty array could be found. When using AVCaptureMultiCamSession, multiple devices may be run simultaneously. You may also run simultaneous streams from a virtual device such as the Dual Camera. By inspecting a virtual device's constituentDevices property, you can find its underlying physical devices and, using this method, search for ports originating from one of those constituent devices. Note that the AVCaptureInput.ports array does not include constituent device ports for virtual devices. You must use this accessor method to discover the ports for which you're specifically looking. These constituent device ports may be used to make connections to outputs for use with an AVCaptureMultiCamSession. Using the Dual Camera as an example, the AVCaptureInput.ports property exposes only those ports supported by the virtual device (it switches automatically between wide and telephoto cameras according to the zoom factor). You may use this method to find the video ports for the constituentDevices. AVCaptureInputPort *wideVideoPort = [dualCameraInput portsWithMediaType:AVMediaTypeVideo sourceDeviceType:AVCaptureDeviceTypeBuiltInWideAngleCamera sourceDevicePosition:AVCaptureDevicePositionBack].firstObject; AVCaptureInputPort *teleVideoPort = [dualCameraInput portsWithMediaType:AVMediaTypeVideo sourceDeviceType:AVCaptureDeviceTypeBuiltInTelephotoCamera sourceDevicePosition:AVCaptureDevicePositionBack].firstObject; These ports may be used to create connections, say, to two AVCaptureVideoDataOutput instances, allowing for synchronized full frame rate delivery of both wide and telephoto streams. As of iOS 13, constituent device ports may not be connected to AVCapturePhotoOutput instances. Clients who wish to capture multiple photos from a virtual device should use AVCapturePhotoOutput's virtualDeviceConstituentPhotoDeliveryEnabled feature. When used in conjunction with an audio device, this method allows you to discover microphones in different AVCaptureDevicePositions. When you intend to work with an AVCaptureMultiCamSession, you may use these ports to make connections and simultaneously capture both front facing and back facing audio simultaneously to two different outputs. When used with an AVCaptureMultiCamSession, the audio device port whose sourceDevicePosition is AVCaptureDevicePositionUnspecified produces omnidirectional sound.
      */
-    portsWithMediaType$sourceDeviceType$sourceDevicePosition$(mediaType: number | null, sourceDeviceType: AVCaptureDeviceType | null, sourceDevicePosition: AVCaptureDevicePosition): _NSArray;
+    portsWithMediaType$sourceDeviceType$sourceDevicePosition$(mediaType: _NSString | null, sourceDeviceType: AVCaptureDeviceType | null, sourceDevicePosition: AVCaptureDevicePosition): _NSArray;
     /**
      * Configures the the device input to follow an external sync device at the given frame duration. - Parameter externalSyncDevice: The ``AVExternalSyncDevice`` hardware to follow. - Parameter videoFrameDuration: The frame duration to which the ``AVExternalSyncDevice`` is calibrated. - Parameter delegate: The delegate to notify when the connection status changes, or an error occurs. Call this method to direct your ``AVCaptureDeviceInput`` to follow the external sync pulse from a sync device at the given frame duration. Your provided `videoFrameDuration` value must match the sync pulse duration of the external sync device. If it does not, the request times out, the external sync device's status returns to ``AVExternalSyncDeviceStatusReady``, and your session stops running, posting a ``AVCaptureSessionRuntimeErrorNotification`` with ``AVErrorFollowExternalSyncDeviceTimedOut``. The ability to follow an external sync device may change depending on the device configuration. For example, ``followExternalSyncDevice:videoFrameDuration:delegate:`` cannot be used when ``AVCaptureDevice/autoVideoFrameRateEnabled`` is `true`. To stop following an external pulse, call ``unfollowExternalSyncDevice``. External sync device following is also disabled when your device's ``AVCaptureDeviceFormat`` changes. Your provided delegate's ``AVExternalSyncDeviceDelegate/externalSyncDeviceStatusDidChange:`` method is called with a status of ``AVExternalSyncDeviceStatusReady`` if the external pulse signal is not close enough to the provided `videoFrameDuration` for successful calibration. Once your ``AVExternalSyncDevice/status`` changes to ``AVExternalSyncDeviceStatusActiveSync``, your input's ``AVCaptureInput/activeExternalSyncVideoFrameDuration`` property reports the up-to-date frame duration. ``AVCaptureInput/activeExternalSyncVideoFrameDuration`` is also reflected in the ``AVCaptureDevice/activeVideoMinFrameDuration`` and ``AVCaptureDevice/activeVideoMaxFrameDuration`` of your input's associated device. - Note: Calling this method may cause a lengthy reconfiguration of the receiver, similar to setting a new active format or ``AVCaptureSession/sessionPreset``. - Important: Calling this method throws an `NSInvalidArgumentException` if ``AVCaptureDeviceInput/externalSyncSupported`` returns `false`. - Important: The provided external sync device's ``status`` must be ``AVExternalSyncDeviceStatusReady`` when you call this method, otherwise an `NSInvalidArgumentException` is thrown.
      */

package/dist/AVFoundation/AVCaptureIndexPicker.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 _AVCaptureIndexPicker extends _AVCaptureControl {
     static alloc(): _AVCaptureIndexPicker;
@@ -21,7 +22,7 @@ export declare class _AVCaptureIndexPicker extends _AVCaptureControl {
     /**
      * Configures the picker's `action` which is called on `actionQueue` whenever the index of the picker is changed. A queue for the `action` to be called. An action called on `actionQueue` whenever the selected index of the picker is changed. Because the camera system may be independent from the main thread or ` `, `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;
     /**
      * The currently selected index. Because the camera system may be independent from the main thread or ` `, `selectedIndex` must be changed on `actionQueue` – the queue provided to `setActionQueue:action:`. The default value is 0. An index may only be set if it is greater than 0 or less than `numberOfIndexes`, otherwise an `NSInvalidArgumentException` is thrown.
      */

package/dist/AVFoundation/AVCaptureInputPort.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVCaptureInput } from "./AVCaptureInput.js";
 import type { AVCaptureDevicePosition } from "./AVCaptureDevicePosition.js";
 import type { AVCaptureDeviceType } from "./AVCaptureDeviceType.js";
@@ -14,11 +15,11 @@ export declare class _AVCaptureInputPort extends _NSObject {
     /**
      * The media type of the data provided by the receiver. The value of this property is a constant describing the type of media, such as AVMediaTypeVideo or AVMediaTypeAudio, provided by the receiver. Media type constants are defined in AVMediaFormat.h.
      */
-    mediaType(): number;
+    mediaType(): _NSString;
     /**
      * The format of the data provided by the receiver. The value of this property is a CMFormatDescription that describes the format of the media data currently provided by the receiver. Clients can be notified of changes to the format by observing the AVCaptureInputPortFormatDescriptionDidChangeNotification.
      */
-    formatDescription(): NobjcObject;
+    formatDescription(): NobjcObject | null;
     /**
      * Whether the receiver should provide data. The value of this property is a BOOL that determines whether the receiver should provide data to outputs when a session is running. Clients can set this property to fine tune which media streams from a given input will be used during capture. The default value is YES.
      */

package/dist/AVFoundation/AVCaptureMetadataInput.d.ts

@@ -16,5 +16,5 @@ export declare class _AVCaptureMetadataInput extends _AVCaptureInput {
     /**
      * Provides metadata to the AVCaptureSession. An AVTimedMetadataGroup of metadata. Will throw an exception if nil. In order to denote a period of no metadata, an empty AVTimedMetadataGroup should be passed. The provided AVTimedMetadataGroup will be provided to the AVCaptureSession. The group's presentation timestamp is expressed in the context of the clock supplied to the initializer. It is not required that the AVTimedMetadataGroup have a duration; an empty AVTimedMetadataGroup can be supplied to denote a period of no metadata.
      */
-    appendTimedMetadataGroup$error$(metadata: _AVTimedMetadataGroup, outError: NobjcObject): boolean;
+    appendTimedMetadataGroup$error$(metadata: _AVTimedMetadataGroup, outError: NobjcObject | null): boolean;
 }

package/dist/AVFoundation/AVCaptureMetadataOutput.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCaptureMetadataOutputObjectsDelegate } from "./AVCaptureMetadataOutputObjectsDelegate.js";
 import type { _AVCaptureOutput } from "./AVCaptureOutput.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSObject } from "../Foundation/NSObject.js";
 import type { CGRect } from "../structs/CGRect.js";
 export declare class _AVCaptureMetadataOutput extends _AVCaptureOutput {
     static alloc(): _AVCaptureMetadataOutput;
@@ -10,7 +10,7 @@ export declare class _AVCaptureMetadataOutput extends _AVCaptureOutput {
     /**
      * Sets the receiver's delegate that will accept metadata objects and dispatch queue on which the delegate will be called. An object conforming to the AVCaptureMetadataOutputObjectsDelegate protocol that will receive metadata objects after they are captured. A dispatch queue on which all delegate methods will be called. When new metadata objects are captured in the receiver's connection, they will be vended to the delegate using the captureOutput:didOutputMetadataObjects:fromConnection: delegate method. All delegate methods will be called on the specified dispatch queue. Clients that need to minimize the chances of metadata being dropped should specify a queue on which a sufficiently small amount of processing is performed along with receiving metadata objects. A serial dispatch queue must be used to guarantee that metadata objects will be delivered in order. The objectsCallbackQueue parameter may not be NULL, except when setting the objectsDelegate to nil otherwise -setMetadataObjectsDelegate:queue: throws an NSInvalidArgumentException.
      */
-    setMetadataObjectsDelegate$queue$(objectsDelegate: _AVCaptureMetadataOutputObjectsDelegate | null, objectsCallbackQueue: NobjcObject): void;
+    setMetadataObjectsDelegate$queue$(objectsDelegate: _AVCaptureMetadataOutputObjectsDelegate | null, objectsCallbackQueue: _NSObject | null): void;
     /**
      * The receiver's delegate. The value of this property is an object conforming to the AVCaptureMetadataOutputObjectsDelegate protocol that will receive metadata objects after they are captured. The delegate is set using the setMetadataObjectsDelegate:queue: method.
      */
@@ -18,7 +18,7 @@ export declare class _AVCaptureMetadataOutput extends _AVCaptureOutput {
     /**
      * The dispatch queue on which all metadata object delegate methods will be called. The value of this property is a dispatch_queue_t. The queue is set using the setMetadataObjectsDelegate:queue: method.
      */
-    metadataObjectsCallbackQueue(): NobjcObject;
+    metadataObjectsCallbackQueue(): _NSObject | null;
     /**
      * Indicates the receiver's supported metadata object types. The value of this property is an NSArray of NSStrings corresponding to AVMetadataObjectType strings defined in AVMetadataObject.h -- one for each metadata object type supported by the receiver. Available metadata object types are dependent on the capabilities of the AVCaptureInputPort to which this receiver's AVCaptureConnection is connected. Clients may specify the types of objects they would like to process by calling setMetadataObjectTypes:. This property is key-value observable.
      */

package/dist/AVFoundation/AVCaptureOutput.d.ts

@@ -1,5 +1,6 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVCaptureConnection } from "./AVCaptureConnection.js";
 import type { _AVMetadataObject } from "./AVMetadataObject.js";
 import type { CGRect } from "../structs/CGRect.js";
@@ -10,7 +11,7 @@ export declare class _AVCaptureOutput extends _NSObject {
     /**
      * @method connectionWithMediaType: @abstract Returns the first connection in the connections array with an inputPort of the specified mediaType. @param mediaType An AVMediaType constant from AVMediaFormat.h, e.g. AVMediaTypeVideo. @discussion This convenience method returns the first AVCaptureConnection in the receiver's connections array that has an AVCaptureInputPort of the specified mediaType. If no connection with the specified mediaType is found, nil is returned.
      */
-    connectionWithMediaType$(mediaType: number): _AVCaptureConnection | null;
+    connectionWithMediaType$(mediaType: _NSString): _AVCaptureConnection | null;
     /**
      * @method transformedMetadataObjectForMetadataObject:connection: @abstract Converts an AVMetadataObject's visual properties to the receiver's coordinates. @param metadataObject An AVMetadataObject originating from the same AVCaptureInput as the receiver. @param connection The receiver's connection whose AVCaptureInput matches that of the metadata object to be converted. @result An AVMetadataObject whose properties are in output coordinates. @discussion AVMetadataObject bounds may be expressed as a rect where {0,0} represents the top left of the picture area, and {1,1} represents the bottom right on an unrotated picture. Face metadata objects likewise express yaw and roll angles with respect to an unrotated picture. -transformedMetadataObjectForMetadataObject:connection: converts the visual properties in the coordinate space of the supplied AVMetadataObject to the coordinate space of the receiver. The conversion takes orientation, mirroring, and scaling into consideration. If the provided metadata object originates from an input source other than the preview layer's, nil will be returned. If an AVCaptureVideoDataOutput instance's connection's videoOrientation or videoMirrored properties are set to non-default values, the output applies the desired mirroring and orientation by physically rotating and or flipping sample buffers as they pass through it. AVCaptureStillImageOutput, on the other hand, does not physically rotate its buffers. It attaches an appropriate kCGImagePropertyOrientation number to captured still image buffers (see ImageIO/CGImageProperties.h) indicating how the image should be displayed on playback. Likewise, AVCaptureMovieFileOutput does not physically apply orientation/mirroring to its sample buffers -- it uses a QuickTime track matrix to indicate how the buffers should be rotated and/or flipped on playback. transformedMetadataObjectForMetadataObject:connection: alters the visual properties of the provided metadata object to match the physical rotation / mirroring of the sample buffers provided by the receiver through the indicated connection. I.e., for video data output, adjusted metadata object coordinates are rotated/mirrored. For still image and movie file output, they are not.
      */

package/dist/AVFoundation/AVCapturePhoto.d.ts

@@ -33,7 +33,7 @@ export declare class _AVCapturePhoto extends _NSObject {
      * @method fileDataRepresentationWithReplacementMetadata:replacementEmbeddedThumbnailPhotoFormat:replacementEmbeddedThumbnailPixelBuffer:replacementDepthData: @abstract Flattens the AVCapturePhoto to an NSData using the file container format (processedFileType or rawFileType) specified in the AVCapturePhotoSettings (e.g. JFIF, HEIF, DNG, DICOM), and allows you to replace metadata, thumbnail, and depth data in the process. @param replacementMetadata A dictionary of keys and values from <ImageIO/CGImageProperties.h>. To preserve existing metadata to the file, pass self.metadata. To strip existing metadata, pass nil. To replace metadata, pass a replacement dictionary. @param replacementEmbeddedThumbnailPhotoFormat A dictionary of keys and values from <AVFoundation/AVVideoSettings.h>. If you pass a non-nil dictionary, AVVideoCodecKey is required, with AVVideoWidthKey and AVVideoHeightKey being optional. To preserve the existing embedded thumbnail photo to the file, pass self.embeddedThumbnailPhotoFormat and pass nil as your replacementEmbeddedThumbnailPixelBuffer parameter. To strip the existing embedded thumbnail, pass nil for both replacementEmbeddedThumbnailPhotoFormat and replacementEmbeddedThumbnailPixelBuffer. To replace the existing embedded thumbnail photo, pass both a non-nil replacementThumbnailPixelBuffer and replacementEmbeddedThumbnailPhotoFormat dictionary. @param replacementEmbeddedThumbnailPixelBuffer A pixel buffer containing a source image to be encoded to the file as the replacement thumbnail image. To preserve the existing embedded thumbnail photo to the file, pass self.embeddedThumbnailPhotoFormat as your replacementEmbeddedThumbnailPhotoFormat parameter and nil as your replacementEmbeddedThumbnailPixelBuffer parameter. To strip the existing embedded thumbnail, pass nil for both replacementEmbeddedThumbnailPhotoFormat and replacementEmbeddedThumbnailPixelBuffer. To replace the existing embedded thumbnail photo, pass both a non-nil replacementThumbnailPixelBuffer and replacementEmbeddedThumbnailPhotoFormat dictionary. @param replacementDepthData Replacement depth data to be written to the flattened file container. To preserve existing depth data to the file, pass self.depthData. To strip it, pass nil. To replace it, pass a new AVDepthData instance. @result An NSData containing bits in the file container's format, or nil if the flattening process fails.
      * @deprecated fileDataRepresentationWithCustomizer:
      */
-    fileDataRepresentationWithReplacementMetadata$replacementEmbeddedThumbnailPhotoFormat$replacementEmbeddedThumbnailPixelBuffer$replacementDepthData$(replacementMetadata: _NSDictionary | null, replacementEmbeddedThumbnailPhotoFormat: _NSDictionary | null, replacementEmbeddedThumbnailPixelBuffer: NobjcObject, replacementDepthData: _AVDepthData | null): _NSData | null;
+    fileDataRepresentationWithReplacementMetadata$replacementEmbeddedThumbnailPhotoFormat$replacementEmbeddedThumbnailPixelBuffer$replacementDepthData$(replacementMetadata: _NSDictionary | null, replacementEmbeddedThumbnailPhotoFormat: _NSDictionary | null, replacementEmbeddedThumbnailPixelBuffer: NobjcObject | null, replacementDepthData: _AVDepthData | null): _NSData | null;
     /**
      * @method CGImageRepresentation @abstract Utility method that converts the AVCapturePhoto's primary photo to a CGImage. @result A CGImageRef, or nil if the conversion process fails. @discussion Each time you access this method, AVCapturePhoto generates a new CGImageRef. When backed by a compressed container (such as HEIC), the CGImageRepresentation is decoded lazily as needed. When backed by an uncompressed format such as BGRA, it is copied into a separate backing buffer whose lifetime is not tied to that of the AVCapturePhoto. For a 12 megapixel image, a BGRA CGImage represents ~48 megabytes per call. If you only intend to use the CGImage for on-screen rendering, use the previewCGImageRepresentation instead. Note that the physical rotation of the CGImageRef matches that of the main image. Exif orientation has not been applied. If you wish to apply rotation when working with UIImage, you can do so by querying the photo's metadata[kCGImagePropertyOrientation] value, and passing it as the orientation parameter to +[UIImage imageWithCGImage:scale:orientation:]. RAW images always return a CGImageRepresentation of nil. If you wish to make a CGImageRef from a RAW image, use CIRAWFilter in the CoreImage framework.
      */

package/dist/AVFoundation/AVCapturePhotoBracketSettings.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCapturePhotoSettings } from "./AVCapturePhotoSettings.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSString } from "../Foundation/NSString.js";
 export declare class _AVCapturePhotoBracketSettings extends _AVCapturePhotoSettings {
     static alloc(): _AVCapturePhotoBracketSettings;
     static new(): _AVCapturePhotoBracketSettings;
@@ -9,11 +9,11 @@ export declare class _AVCapturePhotoBracketSettings extends _AVCapturePhotoSetti
     /**
      * @method photoBracketSettingsWithRawPixelFormatType:processedFormat:bracketedSettings: @abstract Creates an instance of AVCapturePhotoBracketSettings. @param rawPixelFormatType One of the OSTypes contained in AVCapturePhotoOutput's -availableRawPhotoPixelFormatTypes array. May be set to 0 if you do not desire RAW capture. @param processedFormat A dictionary of Core Video pixel buffer attributes or AVVideoSettings, analogous to AVCaptureStillImageOutput's outputSettings property. If you wish an uncompressed format, your dictionary must contain kCVPixelBufferPixelFormatTypeKey, and the format specified must be present in AVCapturePhotoOutput's -availablePhotoPixelFormatTypes array. kCVPixelBufferPixelFormatTypeKey is the only supported key when expressing uncompressed output. 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 only wish to capture RAW, you may pass a non-zero rawPixelFormatType and a nil processedFormat dictionary. If you pass a rawPixelFormatType of 0 AND a nil processedFormat dictionary, the default output of AVVideoCodecTypeJPEG will be delivered. @param bracketedSettings An array of AVCaptureBracketedStillImageSettings objects (defined in AVCaptureStillImageOutput.h). All must be of the same type, either AVCaptureManualExposureBracketedStillImageSettings or AVCaptureAutoExposureBracketedStillImageSettings. bracketedSettings.count must be <= AVCapturePhotoOutput's -maxBracketedCapturePhotoCount. @result An instance of AVCapturePhotoBracketSettings. @discussion An NSInvalidArgumentException is thrown if bracketedSettings is nil, contains zero elements, or mixes and matches different subclasses of AVCaptureBracketedStillImageSettings. AVCapturePhotoBracketSettings do not support flashMode, autoStillImageStabilizationEnabled, livePhotoMovieFileURL or livePhotoMovieMetadata.
      */
-    static photoBracketSettingsWithRawPixelFormatType$processedFormat$bracketedSettings$(rawPixelFormatType: NobjcObject, processedFormat: _NSDictionary | null, bracketedSettings: _NSArray): _AVCapturePhotoBracketSettings;
+    static photoBracketSettingsWithRawPixelFormatType$processedFormat$bracketedSettings$(rawPixelFormatType: number, processedFormat: _NSDictionary | null, bracketedSettings: _NSArray): _AVCapturePhotoBracketSettings;
     /**
      * @method photoBracketSettingsWithRawPixelFormatType:rawFileType:processedFormat:processedFileType:bracketedSettings: @abstract Creates an instance of AVCapturePhotoBracketSettings. @param rawPixelFormatType One of the OSTypes contained in AVCapturePhotoOutput's -availableRawPhotoPixelFormatTypes array. May be set to 0 if you do not desire RAW capture. @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. If you wish an uncompressed format, your dictionary must contain kCVPixelBufferPixelFormatTypeKey, and the format specified must be present in AVCapturePhotoOutput's -availablePhotoPixelFormatTypes array. kCVPixelBufferPixelFormatTypeKey is the only supported key when expressing uncompressed output. 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 only wish to capture RAW, you may pass a non-zero rawPixelFormatType and a nil processedFormat dictionary. If you pass a rawPixelFormatType of 0 AND a nil processedFormat dictionary, the default output of AVVideoCodecTypeJPEG will be delivered. @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. @param bracketedSettings An array of AVCaptureBracketedStillImageSettings objects (defined in AVCaptureStillImageOutput.h). All must be of the same type, either AVCaptureManualExposureBracketedStillImageSettings or AVCaptureAutoExposureBracketedStillImageSettings. bracketedSettings.count must be <= AVCapturePhotoOutput's -maxBracketedCapturePhotoCount. @result An instance of AVCapturePhotoBracketSettings. @discussion An NSInvalidArgumentException is thrown if bracketedSettings is nil, contains zero elements, or mixes and matches different subclasses of AVCaptureBracketedStillImageSettings. AVCapturePhotoBracketSettings do not support flashMode, autoStillImageStabilizationEnabled, livePhotoMovieFileURL or livePhotoMovieMetadata.
      */
-    static photoBracketSettingsWithRawPixelFormatType$rawFileType$processedFormat$processedFileType$bracketedSettings$(rawPixelFormatType: NobjcObject, rawFileType: number | null, processedFormat: _NSDictionary | null, processedFileType: number | null, bracketedSettings: _NSArray): _AVCapturePhotoBracketSettings;
+    static photoBracketSettingsWithRawPixelFormatType$rawFileType$processedFormat$processedFileType$bracketedSettings$(rawPixelFormatType: number, rawFileType: _NSString | null, processedFormat: _NSDictionary | null, processedFileType: _NSString | null, bracketedSettings: _NSArray): _AVCapturePhotoBracketSettings;
     /**
      * @property bracketedSettings @abstract An array of AVCaptureBracketedStillImageSettings objects you passed in -initWithFormat:rawPixelFormatType:bracketedSettings: @discussion This read-only property never returns nil.
      */

package/dist/AVFoundation/AVCapturePhotoCaptureDelegate.d.ts

@@ -32,12 +32,12 @@ export interface _AVCapturePhotoCaptureDelegate {
      * @method captureOutput:didFinishProcessingPhotoSampleBuffer:previewPhotoSampleBuffer:resolvedSettings:bracketSettings:error: @abstract A callback fired when the primary processed photo or photos are done. @param output The calling instance of AVCapturePhotoOutput. @param photoSampleBuffer A CMSampleBuffer containing an uncompressed pixel buffer or compressed data, along with timing information and metadata. May be nil if there was an error. @param previewPhotoSampleBuffer An optional CMSampleBuffer containing an uncompressed, down-scaled preview pixel buffer. Note that the preview sample buffer contains no metadata. Refer to the photoSampleBuffer for metadata (e.g., the orientation). May be nil. @param resolvedSettings An instance of AVCaptureResolvedPhotoSettings indicating which capture features have been selected. @param bracketSettings If this image is being delivered as part of a bracketed capture, the bracketSettings corresponding to this image. Otherwise nil. @param error An error indicating what went wrong if photoSampleBuffer is nil. @discussion If you've requested a single processed image (uncompressed or compressed) capture, the photo is delivered here. If you've requested a bracketed capture, this callback is fired bracketedSettings.count times (once for each photo in the bracket).
      * @deprecated -captureOutput:didFinishProcessingPhoto:error:
      */
-    captureOutput$didFinishProcessingPhotoSampleBuffer$previewPhotoSampleBuffer$resolvedSettings$bracketSettings$error$?(output: _AVCapturePhotoOutput, photoSampleBuffer: NobjcObject, previewPhotoSampleBuffer: NobjcObject, resolvedSettings: _AVCaptureResolvedPhotoSettings, bracketSettings: _AVCaptureBracketedStillImageSettings | null, error: _NSError | null): void;
+    captureOutput$didFinishProcessingPhotoSampleBuffer$previewPhotoSampleBuffer$resolvedSettings$bracketSettings$error$?(output: _AVCapturePhotoOutput, photoSampleBuffer: NobjcObject | null, previewPhotoSampleBuffer: NobjcObject | null, resolvedSettings: _AVCaptureResolvedPhotoSettings, bracketSettings: _AVCaptureBracketedStillImageSettings | null, error: _NSError | null): void;
     /**
      * @method captureOutput:didFinishProcessingRawPhotoSampleBuffer:previewPhotoSampleBuffer:resolvedSettings:bracketSettings:error: @abstract A callback fired when the RAW photo or photos are done. @param output The calling instance of AVCapturePhotoOutput. @param rawSampleBuffer A CMSampleBuffer containing Bayer RAW pixel data, along with timing information and metadata. May be nil if there was an error. @param previewPhotoSampleBuffer An optional CMSampleBuffer containing an uncompressed, down-scaled preview pixel buffer. Note that the preview sample buffer contains no metadata. Refer to the rawSampleBuffer for metadata (e.g., the orientation). May be nil. @param resolvedSettings An instance of AVCaptureResolvedPhotoSettings indicating which capture features have been selected. @param bracketSettings If this image is being delivered as part of a bracketed capture, the bracketSettings corresponding to this image. Otherwise nil. @param error An error indicating what went wrong if rawSampleBuffer is nil. @discussion Single RAW image and bracketed RAW photos are delivered here. If you've requested a RAW bracketed capture, this callback is fired bracketedSettings.count times (once for each photo in the bracket).
      * @deprecated -captureOutput:didFinishProcessingPhoto:error:
      */
-    captureOutput$didFinishProcessingRawPhotoSampleBuffer$previewPhotoSampleBuffer$resolvedSettings$bracketSettings$error$?(output: _AVCapturePhotoOutput, rawSampleBuffer: NobjcObject, previewPhotoSampleBuffer: NobjcObject, resolvedSettings: _AVCaptureResolvedPhotoSettings, bracketSettings: _AVCaptureBracketedStillImageSettings | null, error: _NSError | null): void;
+    captureOutput$didFinishProcessingRawPhotoSampleBuffer$previewPhotoSampleBuffer$resolvedSettings$bracketSettings$error$?(output: _AVCapturePhotoOutput, rawSampleBuffer: NobjcObject | null, previewPhotoSampleBuffer: NobjcObject | null, resolvedSettings: _AVCaptureResolvedPhotoSettings, bracketSettings: _AVCaptureBracketedStillImageSettings | null, error: _NSError | null): void;
     /**
      * @method captureOutput:didFinishRecordingLivePhotoMovieForEventualFileAtURL:resolvedSettings: @abstract A callback fired when the Live Photo movie has captured all its media data, though all media has not yet been written to file. @param output The calling instance of AVCapturePhotoOutput. @param outputFileURL The URL to which the movie file will be written. This URL is equal to your AVCapturePhotoSettings.livePhotoMovieURL. @param resolvedSettings An instance of AVCaptureResolvedPhotoSettings indicating which capture features have been selected. @discussion When this callback fires, no new media is being written to the file. If you are displaying a "Live" badge, this is an appropriate time to dismiss it. The movie file itself is not done being written until the -captureOutput:didFinishProcessingLivePhotoToMovieFileAtURL:duration:photoDisplayTime:resolvedSettings:error: callback fires.
      */

package/dist/AVFoundation/AVCapturePhotoFileDataRepresentationCustomizer.d.ts

@@ -13,7 +13,7 @@ export interface _AVCapturePhotoFileDataRepresentationCustomizer {
     /**
      * @method replacementEmbeddedThumbnailPixelBufferWithPhotoFormat:forPhoto: @abstract A callback in which you may provide a replacement embedded thumbnail image with compression settings, or strip the existing embedded thumbnail image from the flattened file data representation. @param replacementEmbeddedThumbnailPhotoFormatOut On output, a pointer to a dictionary of keys and values from <AVFoundation/AVVideoSettings.h> If you pass a non-nil dictionary, AVVideoCodecKey is required, with AVVideoWidthKey and AVVideoHeightKey being optional. To preserve the existing embedded thumbnail photo to the flattened data, set *replacementEmbeddedThumbnailPhotoFormatOut to photo.embeddedThumbnailPhotoFormat and return nil. To strip the existing embedded thumbnail, set *replacementEmbeddedThumbnailPhotoFormatOut to nil and return nil. To replace the existing embedded thumbnail photo, pass a replacement photo format dictionary and return a non-nil replacement pixel buffer. @param photo The calling instance of AVCapturePhoto. @return A pixel buffer containing a source image to be encoded to the file as the replacement thumbnail image. To preserve the existing embedded thumbnail photo to the flattened data, set *replacementEmbeddedThumbnailPhotoFormatOut to photo.embeddedThumbnailPhotoFormat and return nil. To strip the existing embedded thumbnail, set *replacementEmbeddedThumbnailPhotoFormatOut to nil and return nil. To replace the existing embedded thumbnail photo, pass a replacement photo format dictionary and return a non-nil replacement pixel buffer. @discussion This callback is optional. If your delegate does not implement this callback, the existing embedded thumbnail photo in the in-memory AVCapturePhoto container will be written to the file data representation.
      */
-    replacementEmbeddedThumbnailPixelBufferWithPhotoFormat$forPhoto$?(replacementEmbeddedThumbnailPhotoFormatOut: NobjcObject, photo: _AVCapturePhoto): NobjcObject;
+    replacementEmbeddedThumbnailPixelBufferWithPhotoFormat$forPhoto$?(replacementEmbeddedThumbnailPhotoFormatOut: NobjcObject | null, photo: _AVCapturePhoto): NobjcObject | null;
     /**
      * @method replacementDepthDataForPhoto: @abstract A callback in which you may provide replacement depth data, or strip the existing depth data from the flattened file data representation. @param photo The calling instance of AVCapturePhoto. @return An instance of AVDepthData. To preserve the existing depth data, return photo.depthData. To strip the existing one, return nil. To replace, provide a replacement AVDepthData instance. @discussion This callback is optional. If your delegate does not implement this callback, the existing depth data in the in-memory AVCapturePhoto container will be written to the file data representation.
      */