objcjs-types 0.4.0 → 0.5.1

package/dist/AVFoundation/AVAssetTrack.d.ts

@@ -1,6 +1,6 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSCopying } from "../Foundation/NSCopying.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVAsset } from "./AVAsset.js";
@@ -29,7 +29,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Loads the AVAssetTrackSegment 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. 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. - Parameter trackTime: The trackTime for which an AVAssetTrackSegment is requested. - Parameter completionHandler: A block that is invoked when loading is complete, vending an AVAssetTrackSegment or an error.
      */
-    loadSegmentForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: NobjcObject | null): void;
+    loadSegmentForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: ((_Nullable_result: _AVAssetTrackSegment, arg1: _NSError) => void) | null): void;
     /**
      * Maps the specified trackTime through the appropriate time mapping and returns the resulting sample presentation time. - Parameter trackTime: The trackTime for which a sample presentation time is requested. - Returns: A CMTime; will be invalid if the trackTime is out of range
      * @deprecated Use loadSamplePresentationTime(forTrackTime:) instead
@@ -38,7 +38,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Maps the specified trackTime through the appropriate time mapping and loads the resulting sample presentation time. - Parameter trackTime: The trackTime for which a sample presentation time is requested. - Parameter completionHandler: A block that is invoked when loading is complete, vending a CMTime (which will be invalid if the trackTime is out of range) or an error.
      */
-    loadSamplePresentationTimeForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: NobjcObject | null): void;
+    loadSamplePresentationTimeForTrackTime$completionHandler$(trackTime: CMTime, completionHandler: ((arg0: CMTime, arg1: _NSError) => void) | null): void;
     /**
      * Provides an NSArray of AVMetadataItems, one for each metadata item in the container of the specified format. Becomes callable without blocking when the key @"availableMetadataFormats" has been loaded - Parameter format: The metadata format for which items are requested. - Returns: An NSArray containing AVMetadataItems.
      * @deprecated Use loadMetadata(for:) instead
@@ -47,7 +47,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Loads an NSArray of AVMetadataItems, one for each metadata item in the container of the specified format. - Parameter format: The metadata format for which items are requested. - Parameter completionHandler: A block that is invoked when loading is complete, vending the array of metadata items (which may be empty if there is no metadata of the specified format) or an error.
      */
-    loadMetadataForFormat$completionHandler$(format: AVMetadataFormat, completionHandler: NobjcObject | null): void;
+    loadMetadataForFormat$completionHandler$(format: AVMetadataFormat, completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     /**
      * Provides an NSArray of AVAssetTracks, one for each track associated with the receiver with the specified type of track association. Becomes callable without blocking when the key @"availableTrackAssociationTypes" has been loaded. - Parameter trackAssociationType: The type of track association for which associated tracks are requested. - Returns: An NSArray containing AVAssetTracks; may be empty if there is no associated tracks of the specified type.
      * @deprecated Use loadAssociatedTracks(ofType:) instead
@@ -56,7 +56,7 @@ export declare class _AVAssetTrack extends _NSObject {
     /**
      * Provides an NSArray of AVAssetTracks, one for each track associated with the receiver with the specified type of track association. - Parameter trackAssociationType: The type of track association for which associated tracks are requested. - Parameter completionHandler: A block that is invoked when loading is comlete, vending an array of tracks (which may be empty if there is no associated tracks of the specified type) or an error. `
      */
-    loadAssociatedTracksOfType$completionHandler$(trackAssociationType: AVTrackAssociationType, completionHandler: NobjcObject | null): void;
+    loadAssociatedTracksOfType$completionHandler$(trackAssociationType: AVTrackAssociationType, completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     /**
      * Creates an instance of AVSampleCursor and positions it at or near the specified presentation timestamp. If the receiver's asset has a value of YES for providesPreciseDurationAndTiming, the sample cursor will be accurately positioned at the receiver's last media sample with presentation timestamp less than or equal to the desired timestamp, or, if there are no such samples, the first sample in presentation order. If the receiver's asset has a value of NO for providesPreciseDurationAndTiming, and it is prohibitively expensive to locate the precise sample at the desired timestamp, the sample cursor may be approximately positioned. This method will return nil if there are no samples in the track. - Parameter presentationTimeStamp: The desired initial presentation timestamp of the returned AVSampleCursor. - Returns: An instance of AVSampleCursor.
      */

package/dist/AVFoundation/AVAssetWriter.d.ts

@@ -66,7 +66,7 @@ export declare class _AVAssetWriter extends _NSObject {
     /**
      * Marks all unfinished inputs as finished and completes the writing of the output file. This method returns immediately and causes its work to be performed asynchronously. When the writing of the output file is finished, or if a failure or a cancellation occurs in the meantime, the specified handler will be invoked to indicate completion of the operation. To determine whether the operation succeeded, your handler can check the value of AVAssetWriter.status. If the status is AVAssetWriterStatusFailed, AVAsset.error will contain an instance of NSError that describes the failure. To guarantee that all sample buffers are successfully written, ensure all calls to -[AVAssetWriterInput appendSampleBuffer:] or -[AVAssetWriterInputPixelBufferAdaptor appendPixelBuffer:withPresentationTime:] have returned before invoking this method.
      */
-    finishWritingWithCompletionHandler$(handler: NobjcObject): void;
+    finishWritingWithCompletionHandler$(handler: () => void): void;
     /**
      * Tests whether an input group can be added to the receiver. The AVAssetWriterInputGroup object to be tested. A BOOL indicating whether the input group can be added to the receiver. If outputFileType specifies a container format that does not support mutually exclusive relationships among tracks, or if the specified instance of AVAssetWriterInputGroup contains inputs with media types that cannot be related, the group cannot be added to the AVAssetWriter. This method throws an exception if any of the following conditions are satisfied: - this writer's output file type does not support mutually exclusive relationships among tracks (allowed types are AVFileTypeQuickTimeMovie, AVFileTypeAppleM4A, AVFileTypeAppleM4V, AVFileType3GPP, AVFileTypeMPEG4) - any AVAssetWriterInput in the input group is also present in an input group already added
      */

package/dist/AVFoundation/AVAssetWriterInput.d.ts

@@ -33,7 +33,7 @@ export declare class _AVAssetWriterInput extends _NSObject {
      * Instructs the receiver to invoke a client-supplied block repeatedly, at its convenience, in order to gather media data for writing to the output file. The block should append media data to the input either until the input's readyForMoreMediaData property becomes NO or until there is no more media data to supply (at which point it may choose to mark the input as finished via -markAsFinished). The block should then exit. After the block exits, if the input has not been marked as finished, once the input has processed the media data it has received and becomes ready for more media data again, it will invoke the block again in order to obtain more. A typical use of this method, with a block that supplies media data to an input while respecting the input's readyForMoreMediaData property, might look like this: ```objc [myAVAssetWriterInput requestMediaDataWhenReadyOnQueue:myInputSerialQueue usingBlock:^{ while ([myAVAssetWriterInput isReadyForMoreMediaData]) { CMSampleBufferRef nextSampleBuffer = [self copyNextSampleBufferToWrite]; if (nextSampleBuffer) { [myAVAssetWriterInput appendSampleBuffer:nextSampleBuffer]; CFRelease(nextSampleBuffer); } else { [myAVAssetWriterInput markAsFinished]; break; } } }]; ``` This method is not recommended for use with a push-style buffer source, such as AVCaptureAudioDataOutput or AVCaptureVideoDataOutput, because such a combination will likely require intermediate queueing of buffers. Instead, this method is better suited to a pull-style buffer source such as AVAssetReaderOutput, as illustrated in the above example. When using a push-style buffer source, it is generally better to immediately append each buffer to the AVAssetWriterInput, directly via -[AVAssetWriter appendSampleBuffer:], as it is received. Using this strategy, it is often possible to avoid having to queue up buffers in between the buffer source and the AVAssetWriterInput. Note that many of these push-style buffer sources also produce buffers in real-time, in which case the client should set expectsMediaDataInRealTime to YES. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer. This method throws an exception if this method is called more than once. - Parameter queue: The queue on which the block should be invoked. - Parameter block: The block the input should invoke to obtain media data.
      * @deprecated Use the input receiver's async append(...) method on its own task instead
      */
-    requestMediaDataWhenReadyOnQueue$usingBlock$(queue: _NSObject, block: NobjcObject): void;
+    requestMediaDataWhenReadyOnQueue$usingBlock$(queue: _NSObject, block: () => void): void;
     /**
      * Appends samples to the receiver. The timing information in the sample buffer, considered relative to the time passed to -[AVAssetWriter startSessionAtSourceTime:], will be used to determine the timing of those samples in the output file. For track types other than audio tracks, to determine the duration of all samples in the output file other than the very last sample that's appended, the difference between the sample buffer's output DTS and the following sample buffer's output DTS will be used. The duration of the last sample is determined as follows: 1. If a marker sample buffer with kCMSampleBufferAttachmentKey_EndsPreviousSampleDuration is appended following the last media-bearing sample, the difference between the output DTS of the marker sample buffer and the output DTS of the last media-bearing sample will be used. 2. If the marker sample buffer is not provided and if the output duration of the last media-bearing sample is valid, it will be used. 3. if the output duration of the last media-bearing sample is not valid, the duration of the second-to-last sample will be used. For audio tracks, the properties of each appended sample buffer are used to determine corresponding output durations. The receiver will retain the CMSampleBuffer until it is done with it, and then release it. Do not modify a CMSampleBuffer or its contents after you have passed it to this method. If the sample buffer contains audio data and the AVAssetWriterInput was intialized with an outputSettings dictionary then the format must be linear PCM. If the outputSettings dictionary was nil then audio data can be provided in a compressed format, and it will be passed through to the output without any re-compression. Note that advanced formats like AAC will have encoder delay present in their bitstreams. This data is inserted by the encoder and is necessary for proper decoding, but it is not meant to be played back. Clients who provide compressed audio bitstreams must use kCMSampleBufferAttachmentKey_TrimDurationAtStart to mark the encoder delay (generally restricted to the first sample buffer). Packetization can cause there to be extra audio frames in the last packet which are not meant to be played back. These remainder frames should be marked with kCMSampleBufferAttachmentKey_TrimDurationAtEnd. CMSampleBuffers obtained from AVAssetReader will already have the necessary trim attachments. Please see http://developer.apple.com/mac/library/technotes/tn2009/tn2258.html for more information about encoder delay. When attaching trims make sure that the output PTS of the sample buffer is what you expect. For example if you called -[AVAssetWriter startSessionAtSourceTime:kCMTimeZero] and you want your audio to start at time zero in the output file then make sure that the output PTS of the first non-fully trimmed audio sample buffer is kCMTimeZero. If the sample buffer contains a CVPixelBuffer then the choice of pixel format will affect the performance and quality of the encode. For optimal performance the format of the pixel buffer should match one of the native formats supported by the selected video encoder. Below are some recommendations: The H.264 and HEVC encoders natively support kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange and kCVPixelFormatType_420YpCbCr8BiPlanarFullRange, which should be used with 8-bit 4:2:0 video and full range input respectively; other related pixel formats in CoreVideo/CVPixelBuffer.h are ideal for 4:2:2 and 4:4:4 (and for HEVC, 10-bit). The JPEG encoder on iOS and Apple Silicon macOS natively supports kCVPixelFormatType_422YpCbCr8FullRange. If you need to work in the RGB domain then kCVPixelFormatType_32BGRA is recommended on iOS and macOS. Pixel buffers not in a natively supported format will be converted internally prior to encoding when possible. Pixel format conversions within the same range (video or full) are generally faster than conversions between different ranges. The ProRes encoders can preserve high bit depth sources, supporting up to 12bits/ch. ProRes 4444 can contain a mathematically lossless alpha channel and it doesn't do any chroma subsampling. This makes ProRes 4444 ideal for quality critical applications. If you are working with 8bit sources ProRes is also a good format to use due to its high image quality. Use either of the recommended pixel formats above. Note that RGB pixel formats by definition have 4:4:4 chroma sampling. If you are working with high bit depth sources the following yuv pixel formats are recommended when encoding to ProRes: kCVPixelFormatType_4444AYpCbCr16, kCVPixelFormatType_422YpCbCr16, and kCVPixelFormatType_422YpCbCr10. When working in the RGB domain kCVPixelFormatType_64ARGB is recommended. Scaling and color matching are not currently supported when using AVAssetWriter with any of these high bit depth pixel formats. Please make sure that your track's output settings dictionary specifies the same width and height as the buffers you will be appending. Do not include AVVideoScalingModeKey or AVVideoColorPropertiesKey. As of macOS 10.10 and iOS 8.0, this method can be used to add sample buffers that reference existing data in a file instead of containing media data to be appended to the file. This can be used to generate tracks that are not self-contained. In order to append such a sample reference to the track create a CMSampleBufferRef with a NULL dataBuffer and dataReady set to true and set the kCMSampleBufferAttachmentKey_SampleReferenceURL and kCMSampleBufferAttachmentKey_SampleReferenceByteOffset attachments on the sample buffer. Further documentation on how to create such a "sample reference" sample buffer can be found in the description of the kCMSampleBufferAttachmentKey_SampleReferenceURL and kCMSampleBufferAttachmentKey_SampleReferenceByteOffset attachment keys in the CMSampleBuffer documentation. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer. It is an error to invoke this method before starting a session (via -[AVAssetWriter startSessionAtSourceTime:]) or after ending a session (via -[AVAssetWriter endSessionAtSourceTime:]). This method throws an exception if the sample buffer's media type does not match the asset writer input's media type. - Parameter sampleBuffer: The CMSampleBuffer to be appended. - Returns: A BOOL value indicating success of appending the sample buffer. If a result of NO is returned, clients can check the value of AVAssetWriter.status to determine whether the writing operation completed, failed, or was cancelled. If the status is AVAssetWriterStatusFailed, AVAsset.error will contain an instance of NSError that describes the failure.
      * @deprecated Use SampleBufferReceiver.append(_:) instead
@@ -54,7 +54,7 @@ export declare class _AVAssetWriterInput extends _NSObject {
     /**
      * Instructs the receiver to invoke a client-supplied block whenever a new pass has begun. A typical block passed to this method will perform the following steps: 1. Query the value of the receiver's currentPassDescription property and reconfigure the source of media data (e.g. AVAssetReader) accordingly 2. Call -requestMediaDataWhenReadyOnQueue:usingBlock: to begin appending data for the current pass 3. Exit When all media data has been appended for the current request, call -markCurrentPassAsFinished to begin the process of determining whether an additional pass is warranted. If an additional pass is warranted, the block passed to this method will be invoked to begin the next pass. If no additional passes are needed, the block passed to this method will be invoked one final time so the client can invoke -markAsFinished in response to the value of currentPassDescription becoming nil. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer. This method throws an exception if called more than once. - Parameter queue: The queue on which the block should be invoked. - Parameter block: A block the receiver should invoke whenever a new pass has begun.
      */
-    respondToEachPassDescriptionOnQueue$usingBlock$(queue: _NSObject, block: NobjcObject): void;
+    respondToEachPassDescriptionOnQueue$usingBlock$(queue: _NSObject, block: () => void): void;
     /**
      * Instructs the receiver to analyze the media data that has been appended and determine whether the results could be improved by re-encoding certain segments. When the value of canPerformMultiplePasses is YES, call this method after you have appended all of your media data. After the receiver analyzes whether an additional pass is warranted, the value of currentPassDescription will change (usually asynchronously) to describe how to set up for the next pass. Although it is possible to use key-value observing to determine when the value of currentPassDescription has changed, it is typically more convenient to invoke -respondToEachPassDescriptionOnQueue:usingBlock: in order to start the work for each pass. After re-appending the media data for all of the time ranges of the new pass, call this method again to determine whether additional segments should be re-appended in another pass. Calling this method effectively cancels any previous invocation of -requestMediaDataWhenReadyOnQueue:usingBlock:, meaning that -requestMediaDataWhenReadyOnQueue:usingBlock: can be invoked again for each new pass. -respondToEachPassDescriptionOnQueue:usingBlock: provides a convenient way to consolidate these invocations in your code. After each pass, you have the option of keeping the most recent results by calling -markAsFinished instead of this method. If the value of currentPassDescription is nil at the beginning of a pass, call -markAsFinished to tell the receiver to not expect any further media data. If the value of canPerformMultiplePasses is NO, the value of currentPassDescription will immediately become nil after calling this method. Before calling this method, you must ensure that the receiver is attached to an AVAssetWriter via a prior call to -addInput: and that -startWriting has been called on the asset writer.
      */

package/dist/AVFoundation/AVAsynchronousKeyValueLoading.d.ts

@@ -7,5 +7,5 @@ export interface _AVAsynchronousKeyValueLoading {
     /**
      * @constant AVCaptureInputPortFormatDescriptionDidChangeNotification @abstract This notification is posted when the value of an AVCaptureInputPort instance's formatDescription property changes. @discussion The notification object is the AVCaptureInputPort instance whose format description changed.
      */
-    loadValuesAsynchronouslyForKeys$completionHandler$?(keys: _NSArray, handler: NobjcObject | null): void;
+    loadValuesAsynchronouslyForKeys$completionHandler$?(keys: _NSArray, handler: (() => void) | null): void;
 }

package/dist/AVFoundation/AVCaptionConversionValidator.d.ts

@@ -1,7 +1,7 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _AVCaptionConversionWarning } from "./AVCaptionConversionWarning.js";
 import type { CMTimeRange } from "../structs/CMTimeRange.js";
 import type { AVCaptionConversionValidatorStatus } from "./AVCaptionConversionValidatorStatus.js";
 export declare class _AVCaptionConversionValidator extends _NSObject {
@@ -19,7 +19,7 @@ export declare class _AVCaptionConversionValidator extends _NSObject {
     /**
      * @method validateCaptionConversionWithWarningHandler: @abstract Initiates the specified validation and changes the value of status to AVCaptionConversionValidatorStatusValidating. @param handler Specifies a block to be executed in order to warn you of a specific problem. @discussion It is an error to invoke this method when the value of status is greater than AVCaptionConversionValidatorStatusUnknown. If you wish to stop a validation operation in progress before it has been completed, send the message stopValidating to the receiver. When the validation is complete and all warnings have been reported, the block will be executed once with a value of nil for its warning parameter. When this occurs, the value of status will have been changed to AVCaptionConversionValidatorStatusCompleted.
      */
-    validateCaptionConversionWithWarningHandler$(handler: NobjcObject | null): void;
+    validateCaptionConversionWithWarningHandler$(handler: ((warning: _AVCaptionConversionWarning) => void) | null): void;
     /**
      * @method stopValidating @abstract Stops validation and changes the value of status to AVCaptionConversionValidatorStatusStopped. @discussion You can call this method at any time, even within your warning handler.
      */

package/dist/AVFoundation/AVCaptureDeskViewApplication.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVCaptureDeskViewApplicationLaunchConfiguration } from "./AVCaptureDeskViewApplicationLaunchConfiguration.js";
 export declare class _AVCaptureDeskViewApplication extends _NSObject {
@@ -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 | null): void;
+    presentWithCompletionHandler$(completionHandler: ((error: _NSError) => void) | 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 | null): void;
+    presentWithLaunchConfiguration$completionHandler$(launchConfiguration: _AVCaptureDeskViewApplicationLaunchConfiguration, completionHandler: ((error: _NSError) => void) | null): void;
 }

package/dist/AVFoundation/AVCaptureDevice.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSSet } from "../Foundation/NSSet.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -70,7 +71,7 @@ export declare class _AVCaptureDevice extends _NSObject {
     /**
      * @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: _NSString, handler: NobjcObject): void;
+    static requestAccessForMediaType$completionHandler$(mediaType: _NSString, handler: (granted: boolean) => void): 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.
      */
@@ -178,7 +179,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 | null): void;
+    setFocusModeLockedWithLensPosition$completionHandler$(lensPosition: number, handler: ((syncTime: CMTime) => void) | 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 +203,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 | null): void;
+    setExposureModeCustomWithDuration$ISO$completionHandler$(duration: CMTime, ISO: number, handler: ((syncTime: CMTime) => void) | 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 | null): void;
+    setExposureTargetBias$completionHandler$(bias: number, handler: ((syncTime: CMTime) => void) | 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 +215,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 | null): void;
+    setWhiteBalanceModeLockedWithDeviceWhiteBalanceTemperatureAndTintValues$completionHandler$(whiteBalanceTemperatureAndTintValues: AVCaptureWhiteBalanceTemperatureAndTintValues, handler: ((syncTime: CMTime) => void) | 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 | null): void;
+    setWhiteBalanceModeLockedWithDeviceWhiteBalanceGains$completionHandler$(whiteBalanceGains: AVCaptureWhiteBalanceGains, handler: ((syncTime: CMTime) => void) | 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 +255,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 | null): void;
+    setDynamicAspectRatio$completionHandler$(dynamicAspectRatio: AVCaptureAspectRatio, handler: ((syncTime: CMTime, error: _NSError) => void) | 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/AVCaptureIndexPicker.d.ts

@@ -1,4 +1,3 @@
-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";
@@ -14,7 +13,7 @@ export declare class _AVCaptureIndexPicker extends _AVCaptureControl {
     /**
      * Initializes an `AVCaptureIndexPicker` to pick between `numberOfIndexes` values. A localized string that describes the picker's `action`. The name of a symbol to represent the picker. The number of indexes to pick between. `numberOfIndexes` must be greater than 0, otherwise an `NSInvalidArgumentException` is thrown. A transformation from index to localized title. An `AVCaptureIndexPicker` instance that picks between `numberOfIndexes` values with a transformation from index to localized title. Suitable when you want to provide a title for each picked value lazily.
      */
-    initWithLocalizedTitle$symbolName$numberOfIndexes$localizedTitleTransform$(localizedTitle: _NSString, symbolName: _NSString, numberOfIndexes: number, localizedTitleTransform: NobjcObject): _AVCaptureIndexPicker;
+    initWithLocalizedTitle$symbolName$numberOfIndexes$localizedTitleTransform$(localizedTitle: _NSString, symbolName: _NSString, numberOfIndexes: number, localizedTitleTransform: (index: number) => _NSString): _AVCaptureIndexPicker;
     /**
      * Initializes an `AVCaptureIndexPicker` to pick between `localizedIndexTitles.count` values. A localized string that describes the picker's `action`. The name of a symbol to represent the picker. The titles to use for each index. `localizedIndexTitles` must be greater than 0, otherwise an `NSInvalidArgumentException` is thrown. An `AVCaptureIndexPicker` instance that picks between `localizedIndexTitles.count` values. Suitable when you already have an array containing a title for each picked value.
      */
@@ -22,7 +21,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: _NSObject, action: NobjcObject): void;
+    setActionQueue$action$(actionQueue: _NSObject, action: (selectedIndex: number) => void): 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/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 { _NSError } from "../Foundation/NSError.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { CMVideoDimensions } from "../structs/CMVideoDimensions.js";
 import type { AVCapturePhotoOutputCaptureReadiness } from "./AVCapturePhotoOutputCaptureReadiness.js";
@@ -37,7 +38,7 @@ 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 | null): void;
+    setPreparedPhotoSettingsArray$completionHandler$(preparedPhotoSettingsArray: _NSArray, completionHandler: ((prepared: boolean, error: _NSError) => void) | 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.
      */

package/dist/AVFoundation/AVCaptureSlider.d.ts

@@ -1,4 +1,3 @@
-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";
@@ -22,7 +21,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: _NSObject, action: NobjcObject): void;
+    setActionQueue$action$(actionQueue: _NSObject, action: (newValue: number) => void): 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/AVCaptureStillImageOutput.d.ts

@@ -1,9 +1,11 @@
 import type { NobjcObject } from "objc-js";
+import type { _AVCaptureBracketedStillImageSettings } from "./AVCaptureBracketedStillImageSettings.js";
 import type { _AVCaptureConnection } from "./AVCaptureConnection.js";
 import type { _AVCaptureOutput } from "./AVCaptureOutput.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 export declare class _AVCaptureStillImageOutput extends _AVCaptureOutput {
     static alloc(): _AVCaptureStillImageOutput;
     static new(): _AVCaptureStillImageOutput;
@@ -15,17 +17,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 | null): void;
+    captureStillImageAsynchronouslyFromConnection$completionHandler$(connection: _AVCaptureConnection, handler: ((imageDataSampleBuffer: NobjcObject, error: _NSError) => void) | 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 | null): void;
+    prepareToCaptureStillImageBracketFromConnection$withSettingsArray$completionHandler$(connection: _AVCaptureConnection, settings: _NSArray, handler: ((prepared: boolean, error: _NSError) => void) | 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 | null): void;
+    captureStillImageBracketAsynchronouslyFromConnection$withSettingsArray$completionHandler$(connection: _AVCaptureConnection, settings: _NSArray, handler: ((sampleBuffer: NobjcObject, stillImageSettings: _AVCaptureBracketedStillImageSettings, error: _NSError) => void) | 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/AVCaptureSystemExposureBiasSlider.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCaptureControl } from "./AVCaptureControl.js";
 import type { _AVCaptureDevice } from "./AVCaptureDevice.js";
 export declare class _AVCaptureSystemExposureBiasSlider extends _AVCaptureControl {
@@ -12,5 +11,5 @@ export declare class _AVCaptureSystemExposureBiasSlider extends _AVCaptureContro
     /**
      * Initializes an `AVCaptureSystemExposureBiasSlider` for controlling `device` with a ` ` `action` for handling `exposureTargetBias` changes. The device to control. An action called on ` ` to handle `exposureTargetBias` changes by `AVCaptureSystemExposureBiasSlider`. `action` is **only** called when `exposureTargetBias` is changed by this control. Clients should not change `exposureTargetBias` on the device when `action` is called. If you need to react to other sources of `exposureTargetBias` changes, you will still need to use key-value observation. `AVCaptureSystemExposureBiasSlider` may only be initialized with `AVCaptureDevice` instances that support setting `exposureTargetBias`, otherwise an `NSInvalidArgumentException` is thrown.
      */
-    initWithDevice$action$(device: _AVCaptureDevice, action: NobjcObject): _AVCaptureSystemExposureBiasSlider;
+    initWithDevice$action$(device: _AVCaptureDevice, action: (exposureTargetBias: number) => void): _AVCaptureSystemExposureBiasSlider;
 }

package/dist/AVFoundation/AVCaptureSystemZoomSlider.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVCaptureControl } from "./AVCaptureControl.js";
 import type { _AVCaptureDevice } from "./AVCaptureDevice.js";
 export declare class _AVCaptureSystemZoomSlider extends _AVCaptureControl {
@@ -12,5 +11,5 @@ export declare class _AVCaptureSystemZoomSlider extends _AVCaptureControl {
     /**
      * @method initWithDevice:action @abstract Initializes an `AVCaptureSystemZoomSlider` for controlling `device` with a `@MainActor` `action` for handling `videoZoomFactor` changes. @param device The device to control. @param action An action called on `@MainActor` to handle `videoZoomFactor` changes by `AVCaptureSystemZoomSlider`. @discussion `action` is **only** called when `videoZoomFactor` is changed by this control. Clients should not change `videoZoomFactor` on the device when `action` is called. If you need to react to other sources of `videoZoomFactor` changes like `rampToVideoZoomFactor:withRate:` you will still need to use key-value observation. `AVCaptureSystemZoomSlider` may only be initialized with `AVCaptureDevice` instances that support setting `videoZoomFactor`, otherwise an `NSInvalidArgumentException` is thrown.
      */
-    initWithDevice$action$(device: _AVCaptureDevice, action: NobjcObject): _AVCaptureSystemZoomSlider;
+    initWithDevice$action$(device: _AVCaptureDevice, action: (videoZoomFactor: number) => void): _AVCaptureSystemZoomSlider;
 }

package/dist/AVFoundation/AVComposition.d.ts

@@ -1,9 +1,9 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVAsset } from "./AVAsset.js";
 import type { _AVCompositionTrack } from "./AVCompositionTrack.js";
 import type { _AVMediaSelectionGroup } from "./AVMediaSelectionGroup.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSLocale } from "../Foundation/NSLocale.js";
 import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -17,10 +17,6 @@ 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: 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: 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
      */
@@ -28,7 +24,7 @@ export declare class _AVComposition extends _AVAsset {
     /**
      * 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: _NSString, completionHandler: NobjcObject | null): void;
+    loadTracksWithMediaType$completionHandler$(mediaType: _NSString, completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | 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
      */
@@ -36,7 +32,7 @@ export declare class _AVComposition extends _AVAsset {
     /**
      * 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: _NSString, completionHandler: NobjcObject | null): void;
+    loadTracksWithMediaCharacteristic$completionHandler$(mediaCharacteristic: _NSString, completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     metadataForFormat$(format: AVMetadataFormat): _NSArray;
     chapterMetadataGroupsWithTitleLocale$containingItemsWithCommonKeys$(locale: _NSLocale, commonKeys: _NSArray | null): _NSArray;
     chapterMetadataGroupsBestMatchingPreferredLanguages$(preferredLanguages: _NSArray): _NSArray;

package/dist/AVFoundation/AVContentKeyRequest.d.ts

@@ -15,7 +15,7 @@ export declare class _AVContentKeyRequest extends _NSObject {
     /**
      * Obtains a content key request data for a specific combination of application and content. If option AVContentKeyRequestProtocolVersionsKey is not specified the default protocol version of 1 is assumed. - Parameter appIdentifier: An opaque identifier for the application. The value of this identifier depends on the particular system used to provide the content key. - Parameter contentIdentifier: An optional opaque identifier for the content. The value of this identifier depends on the particular system used to provide the content key. - Parameter options: Additional information necessary to obtain the key, or nil if none. See AVContentKeyRequest*Key below. - Parameter handler: Once the streaming content key request is prepared, this block will be called with the request data or an error describing the failure.
      */
-    makeStreamingContentKeyRequestDataForApp$contentIdentifier$options$completionHandler$(appIdentifier: _NSData, contentIdentifier: _NSData | null, options: _NSDictionary | null, handler: NobjcObject | null): void;
+    makeStreamingContentKeyRequestDataForApp$contentIdentifier$options$completionHandler$(appIdentifier: _NSData, contentIdentifier: _NSData | null, options: _NSDictionary | null, handler: ((contentKeyRequestData: _NSData, error: _NSError) => void) | null): void;
     /**
      * Informs the receiver to process the specified content key response. After you receive an AVContentKeyRequest via -contentKeySession:didProvideContentKeyRequest: and after you invoke -[AVContentKeyRequest makeStreamingContentKeyRequestDataForApp:contentIdentifier:options:completionHandler:] on that request, you must obtain a response to the request in accordance with the protocol in use by the entity that controls the use of the media data. This is the method you use to provide the content key response to make protected content available for processing. If obtaining the content key response fails, use -processContentKeyResponseError:. - Parameter keyResponse: An instance of AVContentKeyResponse carrying a response to a content key request.
      */

package/dist/AVFoundation/AVContentKeySession.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _AVContentKeyRecipient } from "./AVContentKeyRecipient.js";
@@ -47,15 +48,15 @@ export declare class _AVContentKeySession extends _NSObject {
     /**
      * Creates a secure server playback context (SPC) that the client could send to the key server to obtain an expiration date for the provided persistable content key data. - Parameter persistableContentKeyData: Persistable content key data that was previously created using -[AVContentKeyRequest persistableContentKeyFromKeyVendorResponse:options:error:] or obtained via AVContentKeySessionDelegate callback -contentKeySession:didUpdatePersistableContentKey:forContentKeyIdentifier:. - Parameter handler: Once the secure token is ready, this block will be called with the token or an error describing the failure.
      */
-    makeSecureTokenForExpirationDateOfPersistableContentKey$completionHandler$(persistableContentKeyData: _NSData, handler: NobjcObject | null): void;
+    makeSecureTokenForExpirationDateOfPersistableContentKey$completionHandler$(persistableContentKeyData: _NSData, handler: ((secureTokenData: _NSData, error: _NSError) => void) | null): void;
     /**
      * Invalidates the persistable content key and creates a secure server playback context (SPC) that the client could send to the key server to verify the outcome of invalidation request. Once invalidated, a persistable content key cannot be used to answer key requests during later playback sessions. - Parameter persistableContentKeyData: Persistable content key data that was previously created using -[AVContentKeyRequest persistableContentKeyFromKeyVendorResponse:options:error:] or obtained via AVContentKeySessionDelegate callback -contentKeySession:didUpdatePersistableContentKey:forContentKeyIdentifier:. - Parameter options: Additional information necessary to generate the server playback context, or nil if none. See AVContentKeySessionServerPlaybackContextOption for supported options. - Parameter handler: Once the server playback context is ready, this block will be called with the data or an error describing the failure.
      */
-    invalidatePersistableContentKey$options$completionHandler$(persistableContentKeyData: _NSData, options: _NSDictionary | null, handler: NobjcObject | null): void;
+    invalidatePersistableContentKey$options$completionHandler$(persistableContentKeyData: _NSData, options: _NSDictionary | null, handler: ((secureTokenData: _NSData, error: _NSError) => void) | null): void;
     /**
      * Invalidates all persistable content keys associated with the application and creates a secure server playback context (SPC) that the client could send to the key server to verify the outcome of invalidation request. Once invalidated, persistable content keys cannot be used to answer key requests during later playback sessions. - Parameter appIdentifier: An opaque identifier for the application. The contents of this identifier depend on the particular protocol in use by the entity that controls the use of the media data. - Parameter options: Additional information necessary to generate the server playback context, or nil if none. See AVContentKeySessionServerPlaybackContextOption for supported options. - Parameter handler: Once the server playback context is ready, this block will be called with the data or an error describing the failure.
      */
-    invalidateAllPersistableContentKeysForApp$options$completionHandler$(appIdentifier: _NSData, options: _NSDictionary | null, handler: NobjcObject | null): void;
+    invalidateAllPersistableContentKeysForApp$options$completionHandler$(appIdentifier: _NSData, options: _NSDictionary | null, handler: ((secureTokenData: _NSData, error: _NSError) => void) | null): void;
     /**
      * Informs the receiver that the specified recipient will be used for the session. It is an error to add recipient to sessions that have received an expire message. It is also an error to add recipients after they have already begun to process media data (e.g. after an AVURLAsset has loaded the values of any of its keys). Such errors will result in NSInternalInconsistencyExceptions. Sending this message to an AVContentKeySession is atomic.
      */

package/dist/AVFoundation/AVError.d.ts

@@ -0,0 +1,88 @@
+export declare const AVError: {
+    readonly Unknown: -11800;
+    readonly OutOfMemory: -11801;
+    readonly SessionNotRunning: -11803;
+    readonly DeviceAlreadyUsedByAnotherSession: -11804;
+    readonly NoDataCaptured: -11805;
+    readonly SessionConfigurationChanged: -11806;
+    readonly DiskFull: -11807;
+    readonly DeviceWasDisconnected: -11808;
+    readonly MediaChanged: -11809;
+    readonly MaximumDurationReached: -11810;
+    readonly MaximumFileSizeReached: -11811;
+    readonly MediaDiscontinuity: -11812;
+    readonly MaximumNumberOfSamplesForFileFormatReached: -11813;
+    readonly DeviceNotConnected: -11814;
+    readonly DeviceInUseByAnotherApplication: -11815;
+    readonly DeviceLockedForConfigurationByAnotherProcess: -11817;
+    readonly ExportFailed: -11820;
+    readonly DecodeFailed: -11821;
+    readonly InvalidSourceMedia: -11822;
+    readonly FileAlreadyExists: -11823;
+    readonly CompositionTrackSegmentsNotContiguous: -11824;
+    readonly InvalidCompositionTrackSegmentDuration: -11825;
+    readonly InvalidCompositionTrackSegmentSourceStartTime: -11826;
+    readonly InvalidCompositionTrackSegmentSourceDuration: -11827;
+    readonly FileFormatNotRecognized: -11828;
+    readonly FileFailedToParse: -11829;
+    readonly MaximumStillImageCaptureRequestsExceeded: -11830;
+    readonly ContentIsProtected: -11831;
+    readonly NoImageAtTime: -11832;
+    readonly DecoderNotFound: -11833;
+    readonly EncoderNotFound: -11834;
+    readonly ContentIsNotAuthorized: -11835;
+    readonly ApplicationIsNotAuthorized: -11836;
+    readonly OperationNotSupportedForAsset: -11838;
+    readonly DecoderTemporarilyUnavailable: -11839;
+    readonly EncoderTemporarilyUnavailable: -11840;
+    readonly InvalidVideoComposition: -11841;
+    readonly ReferenceForbiddenByReferencePolicy: -11842;
+    readonly InvalidOutputURLPathExtension: -11843;
+    readonly ScreenCaptureFailed: -11844;
+    readonly DisplayWasDisabled: -11845;
+    readonly TorchLevelUnavailable: -11846;
+    readonly IncompatibleAsset: -11848;
+    readonly FailedToLoadMediaData: -11849;
+    readonly ServerIncorrectlyConfigured: -11850;
+    readonly ApplicationIsNotAuthorizedToUseDevice: -11852;
+    readonly FailedToParse: -11853;
+    readonly FileTypeDoesNotSupportSampleReferences: -11854;
+    readonly UndecodableMediaData: -11855;
+    readonly AirPlayControllerRequiresInternet: -11856;
+    readonly AirPlayReceiverRequiresInternet: -11857;
+    readonly VideoCompositorFailed: -11858;
+    readonly RecordingAlreadyInProgress: -11859;
+    readonly CreateContentKeyRequestFailed: -11860;
+    readonly UnsupportedOutputSettings: -11861;
+    readonly OperationNotAllowed: -11862;
+    readonly ContentIsUnavailable: -11863;
+    readonly FormatUnsupported: -11864;
+    readonly MalformedDepth: -11865;
+    readonly ContentNotUpdated: -11866;
+    readonly NoLongerPlayable: -11867;
+    readonly NoCompatibleAlternatesForExternalDisplay: -11868;
+    readonly NoSourceTrack: -11869;
+    readonly ExternalPlaybackNotSupportedForAsset: -11870;
+    readonly OperationNotSupportedForPreset: -11871;
+    readonly SessionHardwareCostOverage: -11872;
+    readonly UnsupportedDeviceActiveFormat: -11873;
+    readonly IncorrectlyConfigured: -11875;
+    readonly SegmentStartedWithNonSyncSample: -11876;
+    readonly RosettaNotInstalled: -11877;
+    readonly OperationCancelled: -11878;
+    readonly ContentKeyRequestCancelled: -11879;
+    readonly InvalidSampleCursor: -11880;
+    readonly FailedToLoadSampleData: -11881;
+    readonly AirPlayReceiverTemporarilyUnavailable: -11882;
+    readonly EncodeFailed: -11883;
+    readonly SandboxExtensionDenied: -11884;
+    readonly ToneMappingFailed: -11885;
+    readonly MediaExtensionDisabled: -11886;
+    readonly MediaExtensionConflict: -11887;
+    readonly ContentKeyRequestPlaybackDestinationDoesNotSupportDeviceIdentifierRandomization: -11888;
+    readonly ContentKeyInvalid: -11889;
+    readonly NoSmartFramingsEnabled: -11890;
+    readonly AutoWhiteBalanceNotLocked: -11891;
+    readonly FollowExternalSyncDeviceTimedOut: -11892;
+};
+export type AVError = typeof AVError[keyof typeof AVError];