objcjs-types 0.4.0 → 0.5.1

package/dist/AVFAudio/AVAudioApplication.d.ts

@@ -9,11 +9,11 @@ export declare class _AVAudioApplication extends _NSObject {
     /**
      * @brief Checks to see if calling process has permission to record audio. The 'response' block will be called immediately if permission has already been granted or denied. Otherwise, it presents a dialog to notify the user and allow them to choose, and calls the block once the UI has been dismissed. 'granted' indicates whether permission has been granted. Note that the block may be called in a different thread context.
      */
-    static requestRecordPermissionWithCompletionHandler$(response: NobjcObject): void;
+    static requestRecordPermissionWithCompletionHandler$(response: (granted: boolean) => void): void;
     /**
      * @brief Checks to see if calling process has permission to inject audio to input stream. The 'response' block will be called immediately if permission has already been granted or denied or if the service is disabled by the user. Otherwise, it presents a dialog to notify the user and allow them to choose, and calls the block once the UI has been dismissed. 'granted' indicates whether permission has been granted. Note that the block may be called in a different thread context.
      */
-    static requestMicrophoneInjectionPermissionWithCompletionHandler$(response: NobjcObject): void;
+    static requestMicrophoneInjectionPermissionWithCompletionHandler$(response: (permission: AVAudioApplicationMicrophoneInjectionPermission) => void): void;
     /** Returns the singleton instance */
     static sharedInstance(): _AVAudioApplication;
     /**
@@ -23,7 +23,7 @@ export declare class _AVAudioApplication extends _NSObject {
     /**
      * @brief Provide a block that implements your app's input (microphone) muting logic (macOS only). The block will be called whenever the input mute state changes, either due to changing the `AVAudioApplication.inputMute` property on this API, or due to a Bluetooth audio accessory gesture (certain AirPods / Beats headphones) changing the mute state. @param inputMuteHandler block that will be called upon every input mute state change. If the boolean `inputShouldBeMuted` is true, your block should mute all input/microphone samples until the next time the handler is called. Your block should return a value of YES if successful, or in exceptional cases return a NO value if the mute action was unsuccesful. Since the input mute handling logic should happen a single place, subsequent calls to this method will overwrite any previously registered block with the one provided. A nil value may be provided to cancel the block being called, e.g. at end of call lifecycle. @note This is available on macOS only - for all other platforms input muting will be handled internally. It is recommended only to perform your input muting logic within this block, and to perform your UI updates for input mute state changes within the handler for AVAudioApplicationInputMuteStateChangeNotification. This handler should be set by the process doing the call's audio I/O.
      */
-    setInputMuteStateChangeHandler$error$(inputMuteHandler: NobjcObject | null, outError: NobjcObject | null): boolean;
+    setInputMuteStateChangeHandler$error$(inputMuteHandler: ((inputShouldBeMuted: boolean) => boolean) | null, outError: NobjcObject | null): boolean;
     /**
      * Get the input muted state - return value is boolean 0 for unmuted or value 1 for muted (input samples zeroed out)
      */

package/dist/AVFAudio/AVAudioConverter.d.ts

@@ -30,7 +30,7 @@ export declare class _AVAudioConverter extends _NSObject {
     /**
      * @method convertToBuffer:error:withInputFromBlock: @abstract Perform any supported conversion. @param inputBlock A block which will be called to get input data as needed. See description for AVAudioConverterInputBlock. @param outputBuffer The output buffer. @param outError An error if the conversion fails. @return An AVAudioConverterOutputStatus is returned. @discussion It attempts to fill the buffer to its capacity. On return, the buffer's length indicates the number of sample frames successfully converted.
      */
-    convertToBuffer$error$withInputFromBlock$(outputBuffer: _AVAudioBuffer, outError: NobjcObject | null, inputBlock: NobjcObject): AVAudioConverterOutputStatus;
+    convertToBuffer$error$withInputFromBlock$(outputBuffer: _AVAudioBuffer, outError: NobjcObject | null, inputBlock: (arg0: number, arg1: NobjcObject) => _AVAudioBuffer): AVAudioConverterOutputStatus;
     /**
      * @property inputFormat @abstract The format of the input audio stream. (NB. AVAudioFormat includes the channel layout)
      */

package/dist/AVFAudio/AVAudioEngine.d.ts

@@ -98,20 +98,20 @@ export declare class _AVAudioEngine extends _NSObject {
      * Establish a MIDI only connection between two nodes. The source node. The destination node. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. If non-nil, this block is called from the source node's `AUMIDIOutputEventBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. May be nil. Use this method to establish a MIDI only connection between a source node and a destination node that has MIDI input capability. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. Note that any pre-existing MIDI connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventBlock` will be overwritten when making the MIDI connection.
      * @deprecated connectMIDI:to:format:eventListBlock:
      */
-    connectMIDI$to$format$block$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: NobjcObject | null): void;
+    connectMIDI$to$format$block$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: number, arg3: NobjcObject) => number) | null): void;
     /**
      * Establish a MIDI only connection between two nodes. The source node. The destination node. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. This block is called from the source node's `AUMIDIOutputEventListBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. Use this method to establish a MIDI only connection between a source node and a destination node that has MIDI input capability. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. Note that any pre-existing MIDI connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventListBlock` will be overwritten when making the MIDI connection.
      */
-    connectMIDI$to$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: NobjcObject | null): void;
+    connectMIDI$to$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: NobjcObject) => number) | null): void;
     /**
      * Establish a MIDI only connection between a source node and multiple destination nodes. The source node. An array of AVAudioNodes specifying destination nodes. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. If non-nil, this block is called from the source node's `AUMIDIOutputEventBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. May be nil. Use this method to establish a MIDI only connection between a source node and multiple destination nodes. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. MIDI connections made using this method are either one-to-one (when a single destination connection is specified) or one-to-many (when multiple connections are specified), but never many-to-one. Note that any pre-existing connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventBlock` will be overwritten when making the MIDI connection.
      * @deprecated connectMIDI:toNodes:format:eventListBlock:
      */
-    connectMIDI$toNodes$format$block$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: NobjcObject | null): void;
+    connectMIDI$toNodes$format$block$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: number, arg3: NobjcObject) => number) | null): void;
     /**
      * Establish a MIDI only connection between a source node and multiple destination nodes. The source node. An array of AVAudioNodes specifying destination nodes. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. This block is called from the source node's `AUMIDIOutputEventListBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. Use this method to establish a MIDI only connection between a source node and multiple destination nodes. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. MIDI connections made using this method are either one-to-one (when a single destination connection is specified) or one-to-many (when multiple connections are specified), but never many-to-one. Note that any pre-existing connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventListBlock` will be overwritten when making the MIDI connection.
      */
-    connectMIDI$toNodes$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: NobjcObject | null): void;
+    connectMIDI$toNodes$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: NobjcObject) => number) | null): void;
     /**
      * Remove a MIDI connection between two nodes. The node whose MIDI output is to be disconnected. The node whose MIDI input is to be disconnected. If a tap block is installed on the source node, it will be removed when the last connection from the source node is removed.
      */
@@ -155,7 +155,7 @@ export declare class _AVAudioEngine extends _NSObject {
     /**
      * Block to render the engine operating in manual rendering mode This block based render call must be used to render the engine when operating in `AVAudioEngineManualRenderingModeRealtime`. In this mode, the engine operates under realtime constraints and will not make any blocking call (e.g. calling libdispatch, blocking on a mutex, allocating memory etc.) while rendering. Before invoking the rendering functionality, client must fetch this block and cache the result. The block can then be called from a realtime context, without any possibility of blocking. When rendering in `AVAudioEngineManualRenderingModeOffline`, either this block based render call or `renderOffline:toBuffer:error:` ObjC method can be used. All the rules outlined in `renderOffline:toBuffer:error:` are applicable here as well.
      */
-    manualRenderingBlock(): NobjcObject;
+    manualRenderingBlock(): (arg0: number, arg1: NobjcObject, arg2: NobjcObject) => AVAudioEngineManualRenderingStatus;
     /**
      * Whether or not the engine is operating in manual rendering mode, i.e. not connected to an audio device and rendering in response to the requests from the client
      */

package/dist/AVFAudio/AVAudioInputNode.d.ts

@@ -3,6 +3,7 @@ import type { _AVAudioFormat } from "./AVAudioFormat.js";
 import type { _AVAudioIONode } from "./AVAudioIONode.js";
 import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { AVAudioVoiceProcessingOtherAudioDuckingConfiguration } from "../structs/AVAudioVoiceProcessingOtherAudioDuckingConfiguration.js";
+import type { AVAudioVoiceProcessingSpeechActivityEvent } from "./AVAudioVoiceProcessingSpeechActivityEvent.js";
 export declare class _AVAudioInputNode extends _AVAudioIONode {
     static alloc(): _AVAudioInputNode;
     static new(): _AVAudioInputNode;
@@ -10,11 +11,11 @@ export declare class _AVAudioInputNode extends _AVAudioIONode {
     /**
      * @method setManualRenderingInputPCMFormat:inputBlock: @abstract Supply the data through the input node to the engine operating in the manual rendering mode. @param format The format of the PCM audio data the block will supply to the engine @param block The block the engine will call on the input node to get the audio to send to the output, when operating in the manual rendering mode. See `AVAudioIONodeInputBlock` for more details @return YES for success @discussion This block must be set if the input node is being used when the engine is operating in manual rendering mode. Switching the engine to render to/from an audio device invalidates any previously set block, and makes this method ineffective.
      */
-    setManualRenderingInputPCMFormat$inputBlock$(format: _AVAudioFormat, block: NobjcObject): boolean;
+    setManualRenderingInputPCMFormat$inputBlock$(format: _AVAudioFormat, block: (arg0: number) => NobjcObject): boolean;
     /**
      * @method setMutedSpeechActivityEventListener @abstract Register a listener to be notified when speech activity event occurs while the input is muted. @param listenerBlock The block the engine will call when speech activity event occurs while the input is muted. Passing nil will remove an already set block. @return YES for success @discussion Continuous presence of or lack of speech activity during mute will not cause redundant notification. In order to use this API, it's expected to implement the mute via the voiceProcessingInputMuted.
      */
-    setMutedSpeechActivityEventListener$(listenerBlock: NobjcObject | null): boolean;
+    setMutedSpeechActivityEventListener$(listenerBlock: ((event: AVAudioVoiceProcessingSpeechActivityEvent) => void) | null): boolean;
     /**
      * @property voiceProcessingBypassed @abstract Bypass all processing for microphone uplink done by the voice processing unit. @discussion Querying this property when voice processing is disabled will return false.
      */

package/dist/AVFAudio/AVAudioNode.d.ts

@@ -1,8 +1,8 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVAudioEngine } from "./AVAudioEngine.js";
 import type { _AVAudioFormat } from "./AVAudioFormat.js";
+import type { _AVAudioPCMBuffer } from "./AVAudioPCMBuffer.js";
 import type { _AVAudioTime } from "./AVAudioTime.js";
 import type { _AUAudioUnit } from "../AudioToolbox/AUAudioUnit.js";
 export declare class _AVAudioNode extends _NSObject {
@@ -22,7 +22,7 @@ export declare class _AVAudioNode extends _NSObject {
     /**
      * @method installTapOnBus:bufferSize:format:block: @abstract Create a "tap" to record/monitor/observe the output of the node. @param bus the node output bus to which to attach the tap @param bufferSize the requested size of the incoming buffers in sample frames. Supported range is [100, 400] ms. @param format If non-nil, attempts to apply this as the format of the specified output bus. This should only be done when attaching to an output bus which is not connected to another node; an error will result otherwise. The tap and connection formats (if non-nil) on the specified bus should be identical. Otherwise, the latter operation will override any previously set format. @param tapBlock a block to be called with audio buffers @discussion Only one tap may be installed on any bus. Taps may be safely installed and removed while the engine is running. Note that if you have a tap installed on AVAudioOutputNode, there could be a mismatch between the tap buffer format and AVAudioOutputNode's output format, depending on the underlying physical device. Hence, instead of tapping the AVAudioOutputNode, it is advised to tap the node connected to it. E.g. to capture audio from input node: <pre> AVAudioEngine *engine = [[AVAudioEngine alloc] init]; AVAudioInputNode *input = [engine inputNode]; AVAudioFormat *format = [input outputFormatForBus: 0]; [input installTapOnBus: 0 bufferSize: 8192 format: format block: ^(AVAudioPCMBuffer *buf, AVAudioTime *when) { // ‘buf' contains audio captured from input node at time 'when' }]; .... // start engine </pre>
      */
-    installTapOnBus$bufferSize$format$block$(bus: number, bufferSize: number, format: _AVAudioFormat | null, tapBlock: NobjcObject): void;
+    installTapOnBus$bufferSize$format$block$(bus: number, bufferSize: number, format: _AVAudioFormat | null, tapBlock: (arg0: _AVAudioPCMBuffer, arg1: _AVAudioTime) => void): void;
     /**
      * @method removeTapOnBus: @abstract Destroy a tap. @param bus the node output bus whose tap is to be destroyed
      */

package/dist/AVFAudio/AVAudioPCMBuffer.d.ts

@@ -12,7 +12,7 @@ export declare class _AVAudioPCMBuffer extends _AVAudioBuffer {
     /**
      * @method initWithPCMFormat:bufferListNoCopy:deallocator: @abstract Initialize a buffer that is to contain PCM audio samples with a given AudioBufferList without copying samples and a custom deallocator block. @param format The format of the PCM audio to be contained in the buffer. @param bufferList The buffer list with allocated memory to contain the PCM audio data. @param deallocator A block to invoke when the resulting AVAudioPCMBuffer object is deallocated. @discussion An exception is raised if the format is not PCM. Returns nil in the following cases: - if the format has zero bytes per frame (format.streamDescription->mBytesPerFrame == 0) - if supplied buffer has zero number of buffers - if each buffer's data byte size are not equal or if any of the buffers' data byte size is zero - if there is a mismatch between the format's number of buffers and the AudioBufferList's size (1 if interleaved, mChannelsPerFrame if deinterleaved) - if the AudioBufferList's pointer to the buffer of audio data is null. Use the deallocator block to define your own deallocation behavior for the provided AudioBufferList's underlying memory. The AudioBufferList passed to the deallocator is identical to the one which was passed to the initializer, in terms of the buffer count, and each buffer's mData and mDataByteSize members.
      */
-    initWithPCMFormat$bufferListNoCopy$deallocator$(format: _AVAudioFormat, bufferList: NobjcObject, deallocator: NobjcObject | null): _AVAudioPCMBuffer | null;
+    initWithPCMFormat$bufferListNoCopy$deallocator$(format: _AVAudioFormat, bufferList: NobjcObject, deallocator: ((arg0: NobjcObject) => void) | null): _AVAudioPCMBuffer | null;
     /**
      * @property frameCapacity @abstract The buffer's capacity, in audio sample frames.
      */

package/dist/AVFAudio/AVAudioPlayerNode.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _AVAudioFile } from "./AVAudioFile.js";
 import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
@@ -13,35 +12,35 @@ export declare class _AVAudioPlayerNode extends _AVAudioNode {
     /**
      * @method scheduleBuffer:completionHandler: @abstract Schedule playing samples from an AVAudioBuffer. @param buffer the buffer to play @param completionHandler called after the buffer has been consumed by the player or the player is stopped. may be nil. @discussion Schedules the buffer to be played following any previously scheduled commands. It is possible for the completionHandler to be called before rendering begins or before the buffer is played completely.
      */
-    scheduleBuffer$completionHandler$(buffer: _AVAudioPCMBuffer, completionHandler: NobjcObject | null): void;
+    scheduleBuffer$completionHandler$(buffer: _AVAudioPCMBuffer, completionHandler: (() => void) | null): void;
     /**
      * @method scheduleBuffer:completionCallbackType:completionHandler: @abstract Schedule playing samples from an AVAudioBuffer. @param buffer the buffer to play @param callbackType option to specify when the completion handler must be called @param completionHandler called after the buffer has been consumed by the player or has finished playing back or the player is stopped. may be nil. @discussion Schedules the buffer to be played following any previously scheduled commands.
      */
-    scheduleBuffer$completionCallbackType$completionHandler$(buffer: _AVAudioPCMBuffer, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | null): void;
+    scheduleBuffer$completionCallbackType$completionHandler$(buffer: _AVAudioPCMBuffer, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: ((arg0: AVAudioPlayerNodeCompletionCallbackType) => void) | null): void;
     /**
      * @method scheduleBuffer:atTime:options:completionHandler: @abstract Schedule playing samples from an AVAudioBuffer. @param buffer the buffer to play @param when the time at which to play the buffer. see the discussion of timestamps, above. @param options options for looping, interrupting other buffers, etc. @param completionHandler called after the buffer has been consumed by the player or the player is stopped. may be nil. @discussion It is possible for the completionHandler to be called before rendering begins or before the buffer is played completely.
      */
-    scheduleBuffer$atTime$options$completionHandler$(buffer: _AVAudioPCMBuffer, when: _AVAudioTime | null, options: AVAudioPlayerNodeBufferOptions, completionHandler: NobjcObject | null): void;
+    scheduleBuffer$atTime$options$completionHandler$(buffer: _AVAudioPCMBuffer, when: _AVAudioTime | null, options: AVAudioPlayerNodeBufferOptions, completionHandler: (() => void) | null): void;
     /**
      * @method scheduleBuffer:atTime:options:completionCallbackType:completionHandler: @abstract Schedule playing samples from an AVAudioBuffer. @param buffer the buffer to play @param when the time at which to play the buffer. see the discussion of timestamps, above. @param options options for looping, interrupting other buffers, etc. @param callbackType option to specify when the completion handler must be called @param completionHandler called after the buffer has been consumed by the player or has finished playing back or the player is stopped. may be nil.
      */
-    scheduleBuffer$atTime$options$completionCallbackType$completionHandler$(buffer: _AVAudioPCMBuffer, when: _AVAudioTime | null, options: AVAudioPlayerNodeBufferOptions, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | null): void;
+    scheduleBuffer$atTime$options$completionCallbackType$completionHandler$(buffer: _AVAudioPCMBuffer, when: _AVAudioTime | null, options: AVAudioPlayerNodeBufferOptions, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: ((arg0: AVAudioPlayerNodeCompletionCallbackType) => void) | null): void;
     /**
      * @method scheduleFile:atTime:completionHandler: @abstract Schedule playing of an entire audio file. @param file the file to play @param when the time at which to play the file. see the discussion of timestamps, above. @param completionHandler called after the file has been consumed by the player or the player is stopped. may be nil. @discussion It is possible for the completionHandler to be called before rendering begins or before the file is played completely.
      */
-    scheduleFile$atTime$completionHandler$(file: _AVAudioFile, when: _AVAudioTime | null, completionHandler: NobjcObject | null): void;
+    scheduleFile$atTime$completionHandler$(file: _AVAudioFile, when: _AVAudioTime | null, completionHandler: (() => void) | null): void;
     /**
      * @method scheduleFile:atTime:completionCallbackType:completionHandler: @abstract Schedule playing of an entire audio file. @param file the file to play @param when the time at which to play the file. see the discussion of timestamps, above. @param callbackType option to specify when the completion handler must be called @param completionHandler called after the file has been consumed by the player or has finished playing back or the player is stopped. may be nil.
      */
-    scheduleFile$atTime$completionCallbackType$completionHandler$(file: _AVAudioFile, when: _AVAudioTime | null, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | null): void;
+    scheduleFile$atTime$completionCallbackType$completionHandler$(file: _AVAudioFile, when: _AVAudioTime | null, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: ((arg0: AVAudioPlayerNodeCompletionCallbackType) => void) | null): void;
     /**
      * @method scheduleSegment:startingFrame:frameCount:atTime:completionHandler: @abstract Schedule playing a segment of an audio file. @param file the file to play @param startFrame the starting frame position in the stream @param numberFrames the number of frames to play @param when the time at which to play the region. see the discussion of timestamps, above. @param completionHandler called after the segment has been consumed by the player or the player is stopped. may be nil. @discussion It is possible for the completionHandler to be called before rendering begins or before the segment is played completely.
      */
-    scheduleSegment$startingFrame$frameCount$atTime$completionHandler$(file: _AVAudioFile, startFrame: number, numberFrames: number, when: _AVAudioTime | null, completionHandler: NobjcObject | null): void;
+    scheduleSegment$startingFrame$frameCount$atTime$completionHandler$(file: _AVAudioFile, startFrame: number, numberFrames: number, when: _AVAudioTime | null, completionHandler: (() => void) | null): void;
     /**
      * @method scheduleSegment:startingFrame:frameCount:atTime:completionCallbackType:completionHandler: @abstract Schedule playing a segment of an audio file. @param file the file to play @param startFrame the starting frame position in the stream @param numberFrames the number of frames to play @param when the time at which to play the region. see the discussion of timestamps, above. @param callbackType option to specify when the completion handler must be called @param completionHandler called after the segment has been consumed by the player or has finished playing back or the player is stopped. may be nil.
      */
-    scheduleSegment$startingFrame$frameCount$atTime$completionCallbackType$completionHandler$(file: _AVAudioFile, startFrame: number, numberFrames: number, when: _AVAudioTime | null, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | null): void;
+    scheduleSegment$startingFrame$frameCount$atTime$completionCallbackType$completionHandler$(file: _AVAudioFile, startFrame: number, numberFrames: number, when: _AVAudioTime | null, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: ((arg0: AVAudioPlayerNodeCompletionCallbackType) => void) | null): void;
     /**
      * @method stop @abstract Clear all of the node's previously scheduled events and stop playback. @discussion All of the node's previously scheduled events are cleared, including any that are in the middle of playing. The node's sample time (and therefore the times to which new events are to be scheduled) is reset to 0, and will not proceed until the node is started again (via play or playAtTime). Note that pausing or stopping all the players connected to an engine does not pause or stop the engine or the underlying hardware. The engine must be explicitly paused or stopped for the hardware to stop.
      */

package/dist/AVFAudio/AVAudioRoutingArbiter.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 { AVAudioRoutingArbitrationCategory } from "./AVAudioRoutingArbitrationCategory.js";
 export declare class _AVAudioRoutingArbiter extends _NSObject {
@@ -12,7 +12,7 @@ export declare class _AVAudioRoutingArbiter extends _NSObject {
     /**
      * @method beginArbitrationWithCategory:completionHandler: @abstract Begin routing arbitration to take ownership of nearby Bluetooth audio routes. @discussion When an app wants to participate in automatic audio arbitration for the wireless headphones route, it has to begin arbitration specifying its arbitration session category. It provides the operating system time to arbitrate with other nearby Apple devices to obtain ownership of supported Bluetooth audio devices. Then upon completion of arbitration, the operating system will automatically determine whether to route audio to the nearby Bluetooth device. Once arbitration completes, the application is free to start running audio I/O. I/O will be started upon the app request even if the -beginArbitrationWithCategory:completionHandler: fails. This method should also be used whenever restarting audio I/O in order to allow the system to arbitrate for ownership of a Bluetooth device that may have been taken by another nearby Apple device during the time that I/O was stopped. @param category The category describes the general type of audio that the app plans to use. @param handler A client-supplied block called asynchronously when audio routing arbitration is completed. This completion handler takes the following parameters: defaultDeviceChanged Indicating that the system default audio device has been changed as a result of the arbitration operation. error An error object that indicates why the request failed, or nil if the request was successful.
      */
-    beginArbitrationWithCategory$completionHandler$(category: AVAudioRoutingArbitrationCategory, handler: NobjcObject | null): void;
+    beginArbitrationWithCategory$completionHandler$(category: AVAudioRoutingArbitrationCategory, handler: ((defaultDeviceChanged: boolean, error: _NSError) => void) | null): void;
     /**
      * @method leaveArbitration @abstract Stop participating in audio routing arbitration. @discussion When an application has stopped using audio for the foreseeable future, it should notify the system. For example, in Voice over IP (VoIP) use cases, the application should call -leaveArbitration when the VoIP call has ended. This allows the system to make a better decision when other participating Apple devices would like to take ownership of a nearby Bluetooth device. Applications should not call this API in cases where audio is only momentarily paused.
      */

package/dist/AVFAudio/AVAudioSequencer.d.ts

@@ -49,7 +49,7 @@ export declare class _AVAudioSequencer extends _NSObject {
     /**
      * Add a block which will be called each time the AVAudioSequencer encounters an AVMusicUserEvent during playback. The same callback is called for events which occur on any track in the sequencer. Set the block to nil to disable it.
      */
-    setUserCallback$(userCallback: NobjcObject | null): void;
+    setUserCallback$(userCallback: ((arg0: _AVMusicTrack, arg1: _NSData, arg2: number) => void) | null): void;
     /**
      * Returns the host time that will be (or was) played at the specified beat. This call is only valid if the player is playing and will return 0 with an error if the player is not playing or if the starting position of the player (its "starting beat") was after the specified beat. The method uses the sequence's tempo map to translate a beat time from the starting time and beat of the player.
      */

package/dist/AVFAudio/AVAudioSession.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVAudioSessionDataSourceDescription } from "./AVAudioSessionDataSourceDescription.js";
 import type { _AVAudioSessionDelegate } from "./AVAudioSessionDelegate.js";
@@ -54,7 +55,7 @@ export declare class _AVAudioSession extends _NSObject {
      * Checks to see if calling process has permission to record audio. The 'response' block will be called immediately if permission has already been granted or denied. Otherwise, it presents a dialog to notify the user and allow them to choose, and calls the block once the UI has been dismissed. 'granted' indicates whether permission has been granted. Note that the block may be called in a different thread context.
      * @deprecated Please use AVAudioApplication requestRecordPermissionWithCompletionHandler
      */
-    requestRecordPermission$(response: NobjcObject): void;
+    requestRecordPermission$(response: (granted: boolean) => void): void;
     /**
      * Use this method to temporarily override the output to built-in speaker. This method is only valid for a session using PlayAndRecord category. This change remains in effect only until the current route changes or you call this method again with the AVAudioSessionPortOverrideNone option. Sessions using PlayAndRecord category that always want to prefer the built-in speaker output over the receiver, should use AVAudioSessionCategoryOptionDefaultToSpeaker instead.
      */
@@ -83,7 +84,7 @@ export declare class _AVAudioSession extends _NSObject {
     /**
      * Asynchronously activate the session. This is a relatively time consuming operation. The completion handler will be called when the activation completes or if an error occurs while attempting to activate the session. If the session is configured to use AVAudioSessionRouteSharingPolicyLongFormAudio on watchOS, this method will also cause a route picker to be presented to the user in cases where an appropriate output route has not already been selected automatically. watchOS apps using AVAudioSessionRouteSharingPolicyLongFormAudio should be prepared for this method to fail if no eligible audio route can be activated or if the user cancels the route picker view.
      */
-    activateWithOptions$completionHandler$(options: AVAudioSessionActivationOptions, handler: NobjcObject | null): void;
+    activateWithOptions$completionHandler$(options: AVAudioSessionActivationOptions, handler: ((activated: boolean, error: _NSError) => void) | null): void;
     /**
      * The preferred hardware sample rate for the session. The actual sample rate may be different.
      */

package/dist/AVFAudio/AVAudioSinkNode.d.ts

@@ -7,5 +7,5 @@ export declare class _AVAudioSinkNode extends _AVAudioNode {
     /**
      * @method initWithReceiverBlock: @abstract Create a node with a receiver block. @param block The block that receives audio data from the input. @discussion The receiver block is called when the input data is available. The block will be called on the realtime thread and it is the client's responsibility to handle it in a thread-safe manner and to not make any blocking calls. The audio format for the input bus will be set from the connection format when connecting to another node. The audio format for the data received by the block will be set to the node's input format.
      */
-    initWithReceiverBlock$(block: NobjcObject): _AVAudioSinkNode;
+    initWithReceiverBlock$(block: (arg0: NobjcObject, arg1: number, arg2: NobjcObject) => number): _AVAudioSinkNode;
 }

package/dist/AVFAudio/AVAudioSourceNode.d.ts

@@ -9,11 +9,11 @@ export declare class _AVAudioSourceNode extends _AVAudioNode {
     /**
      * Create a node with a render block. The block to supply audio data to the output. The block can be called on realtime or non-realtime threads depending on the engine’s operating mode and it is the client's responsibility to handle it in a thread-safe manner. The audio format for the output bus will be set from the connection format when connecting to another node. The audio format for the block will be set to the node's output format. If node is reconnected with a different output format, the audio format for the block will also change.
      */
-    initWithRenderBlock$(block: NobjcObject): _AVAudioSourceNode;
+    initWithRenderBlock$(block: (arg0: NobjcObject, arg1: NobjcObject, arg2: number, arg3: NobjcObject) => number): _AVAudioSourceNode;
     /**
      * Create a node with a render block. The format of the PCM audio data that will be supplied by the block. The block to supply audio data to the output. The block can be called on realtime or non-realtime threads depending on the engine’s operating mode and it is the client's responsibility to handle it in a thread-safe manner. The audio format for the output bus will be set from the connection format when connecting to another node. AVAudioSourceNode supports different audio formats for the block and output, but only Linear PCM conversions are supported (sample rate, bit depth, interleaving).
      */
-    initWithFormat$renderBlock$(format: _AVAudioFormat, block: NobjcObject): _AVAudioSourceNode;
+    initWithFormat$renderBlock$(format: _AVAudioFormat, block: (arg0: NobjcObject, arg1: NobjcObject, arg2: number, arg3: NobjcObject) => number): _AVAudioSourceNode;
 }
 export interface _AVAudioSourceNode extends _AVAudioMixing {
 }

package/dist/AVFAudio/AVAudioUnit.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _NSURL } from "../Foundation/NSURL.js";
 import type { _AUAudioUnit } from "../AudioToolbox/AUAudioUnit.js";
@@ -11,7 +12,7 @@ export declare class _AVAudioUnit extends _AVAudioNode {
     /**
      * @method instantiateWithComponentDescription:options:completionHandler: @abstract Asynchronously create an instance of an audio unit component, wrapped in an AVAudioUnit. @param audioComponentDescription The component to instantiate. @param options Instantiation options. @param completionHandler Called in an arbitrary thread/queue context when instantiation is complete. The client should retain the provided AVAudioUnit. @discussion Components whose flags include kAudioComponentFlag_RequiresAsyncInstantiation must be instantiated asynchronously, via this method if they are to be used with AVAudioEngine. See the discussion of this flag in AudioToolbox/AudioComponent.h. The returned AVAudioUnit instance normally will be of a subclass (AVAudioUnitEffect, AVAudioUnitGenerator, AVAudioUnitMIDIInstrument, or AVAudioUnitTimeEffect), selected according to the component's type.
      */
-    static instantiateWithComponentDescription$options$completionHandler$(audioComponentDescription: AudioComponentDescription, options: NobjcObject, completionHandler: NobjcObject | null): void;
+    static instantiateWithComponentDescription$options$completionHandler$(audioComponentDescription: AudioComponentDescription, options: NobjcObject, completionHandler: ((audioUnit: _AVAudioUnit, error: _NSError) => void) | null): void;
     /**
      * @method loadAudioUnitPresetAtURL:error: @abstract Load an audio unit preset. @param url NSURL of the .aupreset file. @param outError A pointer to a NSError object @discussion If the .aupreset file cannot be successfully loaded, an error is returned.
      */

package/dist/AVFAudio/AVAudioUnitComponentManager.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSPredicate } from "../Foundation/NSPredicate.js";
+import type { _AVAudioUnitComponent } from "./AVAudioUnitComponent.js";
 import type { AudioComponentDescription } from "../structs/AudioComponentDescription.js";
 export declare class _AVAudioUnitComponentManager extends _NSObject {
     static alloc(): _AVAudioUnitComponentManager;
@@ -16,7 +17,7 @@ export declare class _AVAudioUnitComponentManager extends _NSObject {
     /**
      * returns an array of AVAudioUnitComponent objects that pass the user provided block method. For each AudioComponent found by the manager, the block method will be called. If the return value is YES then the AudioComponent is added to the resulting array else it will excluded. This gives more control to the block provider to filter out the components returned.
      */
-    componentsPassingTest$(testHandler: NobjcObject): _NSArray;
+    componentsPassingTest$(testHandler: (comp: _AVAudioUnitComponent, stop: NobjcObject) => boolean): _NSArray;
     /**
      * returns an array of AVAudioUnitComponent objects that match the description. This method provides a mechanism to search for AudioComponents using AudioComponentDescription structure. The type, subtype and manufacturer fields are used to search for audio units. A value of 0 for any of these fields is a wildcard and returns the first match found.
      */

package/dist/AVFAudio/AVMIDIPlayer.d.ts

@@ -19,7 +19,7 @@ export declare class _AVMIDIPlayer extends _NSObject {
      */
     prepareToPlay(): void;
     /** Play the sequence. */
-    play$(completionHandler: NobjcObject | null): void;
+    play$(completionHandler: (() => void) | null): void;
     /** Stop playing the sequence. */
     stop(): void;
     /** The length of the currently loaded file in seconds. */

package/dist/AVFAudio/AVMusicTrack.d.ts

@@ -34,7 +34,7 @@ export declare class _AVMusicTrack extends _NSObject {
     /**
      * Iterates through the AVMusicEvents within the AVMusicTrack whose timestamps fit within the range, calling the block for each. the AVMusicEventEnumerationBlock to call for each event. Each event returned via the block should be examined using `NSObject(isKindOfClass:)` to determine its subclass and then cast and accessed/edited accordingly. The iteration may continue after removing an event. The event objects returned via the block will not be the same instances which were added to the AVMusicTrack, though their contents will be identical.
      */
-    enumerateEventsInRange$usingBlock$(range: AVBeatRange, block: NobjcObject): void;
+    enumerateEventsInRange$usingBlock$(range: AVBeatRange, block: (arg0: _AVMusicEvent, arg1: NobjcObject, arg2: NobjcObject) => void): void;
     /**
      * The AVAudioUnit which will receive the track's events This is mutually exclusive with setting a destination MIDIEndpoint. The AU must already be attached to an audio engine, and the track must be part of the AVAudioSequencer associated with that engine. When playing, the track will send its events to that AVAudioUnit. The destination AU cannot be changed while the track's sequence is playing.
      */

package/dist/AVFAudio/AVSpeechSynthesisProviderAudioUnit.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _AUAudioUnit } from "../AudioToolbox/AUAudioUnit.js";
 import type { _AVSpeechSynthesisProviderRequest } from "./AVSpeechSynthesisProviderRequest.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
@@ -20,6 +19,6 @@ export declare class _AVSpeechSynthesisProviderAudioUnit extends _AUAudioUnit {
     /**
      * @brief A property set by the host that is called by the audio unit to supply metadata for a speech request. @discussion A synthesizer should call this method when it has produced relevant data to the audio buffers it is sending back to the host. In some cases speech output may be delayed until these markers are delivered. For example, word highlighting depends on marker data from synthesizers in order to properly time which words are highlighted. Many speech synthesizers generate this information on the fly, while synthesizing the audio. The array of markers can reference future audio buffers that have yet to be delivered. There may be cases in which marker data is not fully known until further audio processing is done. In these cases, and other casers where marker data has changed, calling this block with marker data that contains perviously delivered audio buffer ranges will replace that audio buffer range's marker data, as it will be considered stale.
      */
-    speechSynthesisOutputMetadataBlock(): NobjcObject | null;
-    setSpeechSynthesisOutputMetadataBlock$(value: NobjcObject | null): void;
+    speechSynthesisOutputMetadataBlock(): ((arg0: _NSArray, arg1: _AVSpeechSynthesisProviderRequest) => void) | null;
+    setSpeechSynthesisOutputMetadataBlock$(value: ((arg0: _NSArray, arg1: _AVSpeechSynthesisProviderRequest) => void) | null): void;
 }

package/dist/AVFAudio/AVSpeechSynthesizer.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 { _AVAudioBuffer } from "./AVAudioBuffer.js";
 import type { _AVSpeechSynthesizerDelegate } from "./AVSpeechSynthesizerDelegate.js";
 import type { _AVSpeechUtterance } from "./AVSpeechUtterance.js";
 import type { AVSpeechBoundary } from "./AVSpeechBoundary.js";
@@ -12,7 +12,7 @@ export declare class _AVSpeechSynthesizer extends _NSObject {
     /**
      * Asks the user to allow your app to use personal voices for speech synthesis Call this method before performing any other tasks associated with speech synthesis using personal voices. This method executes asynchronously, returning shortly after you call it. At some point later, the system calls the provided handler block with the results. When your app's authorization status is PersonalVoiceAuthorizationStatus.notDetermined, this method causes the system to prompt the user to grant or deny permission for your app to use personal voices. The user's response is saved so that future calls to this method do not prompt the user again.
      */
-    static requestPersonalVoiceAuthorizationWithCompletionHandler$(handler: NobjcObject): void;
+    static requestPersonalVoiceAuthorizationWithCompletionHandler$(handler: (status: AVSpeechSynthesisPersonalVoiceAuthorizationStatus) => void): void;
     /**
      * Returns your app's current authorization to use personal voices. The user can reject your app's request to use personal voices, but your request can also be denied if personal voices are not supported on the device. The app can also change your app's authorization status at any time from the Settings app. The app's current authorization status value. For a list of values, see AVSpeechSynthesisPersonalVoiceAuthorizationStatus.
      */
@@ -24,11 +24,11 @@ export declare class _AVSpeechSynthesizer extends _NSObject {
     /**
      * Use this method to receive audio buffers that can be used to store or further process synthesized speech. The dictionary provided by -[AVSpeechSynthesisVoice audioFileSettings] can be used to create an AVAudioFile.
      */
-    writeUtterance$toBufferCallback$(utterance: _AVSpeechUtterance, bufferCallback: NobjcObject): void;
+    writeUtterance$toBufferCallback$(utterance: _AVSpeechUtterance, bufferCallback: (arg0: _AVAudioBuffer) => void): void;
     /**
      * Use this method to receive audio buffers and associated metadata that can be used to store or further process synthesized speech. The dictionary provided by -[AVSpeechSynthesisVoice audioFileSettings] can be used to create an AVAudioFile.
      */
-    writeUtterance$toBufferCallback$toMarkerCallback$(utterance: _AVSpeechUtterance, bufferCallback: NobjcObject, markerCallback: NobjcObject): void;
+    writeUtterance$toBufferCallback$toMarkerCallback$(utterance: _AVSpeechUtterance, bufferCallback: (arg0: _AVAudioBuffer) => void, markerCallback: (arg0: _NSArray) => void): void;
     /** Call stopSpeakingAtBoundary: to interrupt current speech and clear the queue. */
     stopSpeakingAtBoundary$(boundary: AVSpeechBoundary): boolean;
     pauseSpeakingAtBoundary$(boundary: AVSpeechBoundary): boolean;

package/dist/AVFoundation/AVAsset.d.ts

@@ -1,6 +1,7 @@
 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 { _NSLocale } from "../Foundation/NSLocale.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
@@ -35,7 +36,7 @@ export declare class _AVAsset extends _NSObject {
     /**
      * Loads an instance of AVAssetTrack that represents the track of the specified trackID. - Parameter trackID: The trackID of the requested AVAssetTrack. - Parameter completionHandler: 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;
+    loadTrackWithTrackID$completionHandler$(trackID: number, completionHandler: ((_Nullable_result: _AVAssetTrack, arg1: _NSError) => void) | null): void;
     /**
      * Provides an array of AVAssetTracks of the asset that present media of the specified media type. Becomes callable without blocking when the key @"tracks" has been loaded - Parameter mediaType: The media type according to which AVAsset filters its AVAssetTracks. (Media types are defined in AVMediaFormat.h.) - Returns: An NSArray of AVAssetTracks; may be empty if no tracks of the specified media type are available.
      * @deprecated Use loadTracks(withMediaType:) instead
@@ -44,7 +45,7 @@ export declare class _AVAsset extends _NSObject {
     /**
      * Loads an array of AVAssetTracks of the asset that present media of the specified media type. - Parameter mediaType: The media type according to which AVAsset filters its AVAssetTracks. (Media types are defined in AVMediaFormat.h.) - Parameter completionHandler: 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 AVAssetTracks of the asset that present media with the specified characteristic. Becomes callable without blocking when the key @"tracks" has been loaded - Parameter mediaCharacteristic: The media characteristic according to which AVAsset filters its AVAssetTracks. (Media characteristics are defined in AVMediaFormat.h.) - Returns: An NSArray of AVAssetTracks; may be empty if no tracks with the specified characteristic are available.
      * @deprecated Use loadTracks(withMediaCharacteristic:) instead
@@ -53,7 +54,7 @@ export declare class _AVAsset extends _NSObject {
     /**
      * Loads an array of AVAssetTracks of the asset that present media with the specified characteristic. - Parameter mediaCharacteristic: The media characteristic according to which AVAsset filters its AVAssetTracks. (Media characteristics are defined in AVMediaFormat.h.) - Parameter completionHandler: 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;
     /**
      * Provides an NSArray of AVMetadataItems, one for each metadata item in the container of the specified format; can subsequently be filtered according to language via +[AVMetadataItem metadataItemsFromArray:filteredAndSortedAccordingToPreferredLanguages:], according to locale via +[AVMetadataItem metadataItemsFromArray:withLocale:], or according to key via +[AVMetadataItem metadataItemsFromArray:withKey:keySpace:]. 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; may be empty if there is no metadata of the specified format.
      * @deprecated Use loadMetadata(for:) instead
@@ -62,7 +63,7 @@ export declare class _AVAsset extends _NSObject {
     /**
      * Loads an NSArray of AVMetadataItems, one for each metadata item in the container of the specified format; can subsequently be filtered according to language via +[AVMetadataItem metadataItemsFromArray:filteredAndSortedAccordingToPreferredLanguages:], according to locale via +[AVMetadataItem metadataItemsFromArray:withLocale:], or according to key via +[AVMetadataItem metadataItemsFromArray:withKey:keySpace:]. - 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 array of chapters. This method returns an array of AVTimedMetadataGroup objects. Each object in the array always contains an AVMetadataItem representing the chapter title; the timeRange property of the AVTimedMetadataGroup object is equal to the time range of the chapter title item. An AVMetadataItem with the specified common key will be added to an existing AVTimedMetadataGroup object if the time range (timestamp and duration) of the metadata item and the metadata group overlaps. The locale of items not carrying chapter titles need not match the specified locale parameter. Further filtering of the metadata items in AVTimedMetadataGroups according to language can be accomplished using +[AVMetadataItem metadataItemsFromArray:filteredAndSortedAccordingToPreferredLanguages:]; filtering of the metadata items according to locale can be accomplished using +[AVMetadataItem metadataItemsFromArray:withLocale:]. - Parameter locale: Locale of the metadata items carrying chapter titles to be returned (supports the IETF BCP 47 specification). - Parameter commonKeys: Array of common keys of AVMetadataItem to be included; can be nil. AVMetadataCommonKeyArtwork is the only supported key for now. - Returns: An NSArray of AVTimedMetadataGroup.
      * @deprecated Use loadChapterMetadataGroups(withTitleLocale:containingItemsWithCommonKeys:) instead
@@ -71,7 +72,7 @@ export declare class _AVAsset extends _NSObject {
     /**
      * Loads an array of chapters. This method vends an array of AVTimedMetadataGroup objects. Each object in the array always contains an AVMetadataItem representing the chapter title; the timeRange property of the AVTimedMetadataGroup object is equal to the time range of the chapter title item. An AVMetadataItem with the specified common key will be added to an existing AVTimedMetadataGroup object if the time range (timestamp and duration) of the metadata item and the metadata group overlaps. The locale of items not carrying chapter titles need not match the specified locale parameter. Further filtering of the metadata items in AVTimedMetadataGroups according to language can be accomplished using +[AVMetadataItem metadataItemsFromArray:filteredAndSortedAccordingToPreferredLanguages:]; filtering of the metadata items according to locale can be accomplished using +[AVMetadataItem metadataItemsFromArray:withLocale:]. - Parameter locale: Locale of the metadata items carrying chapter titles to be returned (supports the IETF BCP 47 specification). - Parameter commonKeys: Array of common keys of AVMetadataItem to be included; if no common keys are required, send an empty list. AVMetadataCommonKeyArtwork is the only supported key for now. - Parameter completionHandler: A block that is invoked when loading is complete, vending the array of timed metadata groups or an error.
      */
-    loadChapterMetadataGroupsWithTitleLocale$containingItemsWithCommonKeys$completionHandler$(locale: _NSLocale, commonKeys: _NSArray, completionHandler: NobjcObject | null): void;
+    loadChapterMetadataGroupsWithTitleLocale$containingItemsWithCommonKeys$completionHandler$(locale: _NSLocale, commonKeys: _NSArray, completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     /**
      * Tests, in order of preference, for a match between language identifiers in the specified array of preferred languages and the available chapter locales, and returns the array of chapters corresponding to the first match that's found. Safe to call without blocking when the AVAsset key availableChapterLocales has status AVKeyValueStatusLoaded. Returns an array of AVTimedMetadataGroup objects. Each object in the array always contains an AVMetadataItem representing the chapter title; the timeRange property of the AVTimedMetadataGroup object is equal to the time range of the chapter title item. All of the available chapter metadata is included in the metadata groups, including items with the common key AVMetadataCommonKeyArtwork, if such items are present. Items not carrying chapter titles will be added to an existing AVTimedMetadataGroup object if the time range (timestamp and duration) of the metadata item and that of the metadata group overlaps. The locale of such items need not match the locale of the chapter titles. Further filtering of the metadata items in AVTimedMetadataGroups according to language can be accomplished using +[AVMetadataItem metadataItemsFromArray:filteredAndSortedAccordingToPreferredLanguages:]; filtering of the metadata items according to locale can be accomplished using +[AVMetadataItem metadataItemsFromArray:withLocale:]. - Parameter preferredLanguages: An array of language identifiers in order of preference, each of which is an IETF BCP 47 (RFC 4646) language identifier. If your goal is to provide the best match for the end user's preferred languages without consideration of your app's available localizations, pass [NSLocale preferredLanguages] as the value of preferredLanguages. However, if you want to filter the available choices in order to obtain the best match among the localizations that are available for your app, pass [NSBundle preferredLocalizationsFromArray:[[NSBundle mainBundle] localizations] forPreferences:[NSLocale preferredLanguages]] instead. The latter choice is normally more appropriate for strings intended for display as part of the app's UI. - Returns: An NSArray of AVTimedMetadataGroup.
      * @deprecated Use loadChapterMetadataGroups(bestMatchingPreferredLanguages:) instead
@@ -80,7 +81,7 @@ export declare class _AVAsset extends _NSObject {
     /**
      * Tests, in order of preference, for a match between language identifiers in the specified array of preferred languages and the available chapter locales, and loads the array of chapters corresponding to the first match that's found. Returns an array of AVTimedMetadataGroup objects. Each object in the array always contains an AVMetadataItem representing the chapter title; the timeRange property of the AVTimedMetadataGroup object is equal to the time range of the chapter title item. All of the available chapter metadata is included in the metadata groups, including items with the common key AVMetadataCommonKeyArtwork, if such items are present. Items not carrying chapter titles will be added to an existing AVTimedMetadataGroup object if the time range (timestamp and duration) of the metadata item and that of the metadata group overlaps. The locale of such items need not match the locale of the chapter titles. Further filtering of the metadata items in AVTimedMetadataGroups according to language can be accomplished using +[AVMetadataItem metadataItemsFromArray:filteredAndSortedAccordingToPreferredLanguages:]; filtering of the metadata items according to locale can be accomplished using +[AVMetadataItem metadataItemsFromArray:withLocale:]. - Parameter preferredLanguages: An array of language identifiers in order of preference, each of which is an IETF BCP 47 (RFC 4646) language identifier. If your goal is to provide the best match for the end user's preferred languages without consideration of your app's available localizations, pass [NSLocale preferredLanguages] as the value of preferredLanguages. However, if you want to filter the available choices in order to obtain the best match among the localizations that are available for your app, pass [NSBundle preferredLocalizationsFromArray:[[NSBundle mainBundle] localizations] forPreferences:[NSLocale preferredLanguages]] instead. The latter choice is normally more appropriate for strings intended for display as part of the app's UI. - Parameter completionHandler: A block that is invoked when loading is complete, vending the array of timed metadata groups or an error.
      */
-    loadChapterMetadataGroupsBestMatchingPreferredLanguages$completionHandler$(preferredLanguages: _NSArray, completionHandler: NobjcObject | null): void;
+    loadChapterMetadataGroupsBestMatchingPreferredLanguages$completionHandler$(preferredLanguages: _NSArray, completionHandler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
     /**
      * Provides an instance of AVMediaSelectionGroup that contains one or more options with the specified media characteristic. Becomes callable without blocking when the key @"availableMediaCharacteristicsWithMediaSelectionOptions" has been loaded. If the asset has no AVMediaSelectionGroup containing options with the specified media characteristic, the return value will be nil. Filtering of the options in the returned AVMediaSelectionGroup according to playability, locale, and additional media characteristics can be accomplished using the category AVMediaSelectionOptionFiltering defined on AVMediaSelectionGroup. - Parameter mediaCharacteristic: A media characteristic for which you wish to obtain the available media selection options. AVMediaCharacteristicAudible, AVMediaCharacteristicLegible, and AVMediaCharacteristicVisual are currently supported. Pass AVMediaCharacteristicAudible to obtain the group of available options for audio media in various languages and for various purposes, such as descriptive audio. Pass AVMediaCharacteristicLegible to obtain the group of available options for subtitles in various languages and for various purposes. Pass AVMediaCharacteristicVisual to obtain the group of available options for video media. - Returns: An instance of AVMediaSelectionGroup. May be nil.
      * @deprecated Use loadMediaSelectionGroup(for:) instead
@@ -90,13 +91,13 @@ export declare class _AVAsset extends _NSObject {
      * Loads an instance of AVMediaSelectionGroup that contains one or more options with the specified media characteristic. If the asset has no AVMediaSelectionGroup containing options with the specified media characteristic, the return value will be nil. Filtering of the options in the returned AVMediaSelectionGroup according to playability, locale, and additional media characteristics can be accomplished using the category AVMediaSelectionOptionFiltering defined on AVMediaSelectionGroup. - Parameter mediaCharacteristic: A media characteristic for which you wish to obtain the available media selection options. AVMediaCharacteristicAudible, AVMediaCharacteristicLegible, and AVMediaCharacteristicVisual are currently supported. Pass AVMediaCharacteristicAudible to obtain the group of available options for audio media in various languages and for various purposes, such as descriptive audio. Pass AVMediaCharacteristicLegible to obtain the group of available options for subtitles in various languages and for various purposes Pass AVMediaCharacteristicVisual to obtain the group of available options for video media. - Parameter completionHandler: A block that is invoked when loading is complete, vending an instance of AVMediaSelectionGroup (which may be nil) or an error.
      * @deprecated Use load(.preferredMediaSelection) instead
      */
-    loadMediaSelectionGroupForMediaCharacteristic$completionHandler$(mediaCharacteristic: _NSString, completionHandler: NobjcObject | null): void;
+    loadMediaSelectionGroupForMediaCharacteristic$completionHandler$(mediaCharacteristic: _NSString, completionHandler: ((_Nullable_result: _AVMediaSelectionGroup, arg1: _NSError) => void) | null): void;
     /** @deprecated Use findUnusedTrackID() instead */
     unusedTrackID(): number;
     /**
      * Loads a track ID that will not collide with any existing track - Parameter completionHandler: A block that is invoked when loading is complete, vending the track ID or an error.
      */
-    findUnusedTrackIDWithCompletionHandler$(completionHandler: NobjcObject | null): void;
+    findUnusedTrackIDWithCompletionHandler$(completionHandler: ((arg0: number, arg1: _NSError) => void) | null): void;
     /**
      * Indicates the duration of the asset. If @"providesPreciseDurationAndTiming" is NO, a best-available estimate of the duration is returned. The degree of precision preferred for timing-related properties can be set at initialization time for assets initialized with URLs - Seealso: AVURLAssetPreferPreciseDurationAndTimingKey for AVURLAsset below.
      */

package/dist/AVFoundation/AVAssetExportSession.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
@@ -34,7 +33,7 @@ export declare class _AVAssetExportSession extends _NSObject {
     /**
      * @method determineCompatibilityOfExportPreset:withAsset:outputFileType:completionHandler: @abstract Performs an inspection on the compatibility of an export preset, AVAsset and output file type. Calls the completion handler with YES if the arguments are compatible; NO otherwise. @discussion Not all export presets are compatible with all AVAssets and file types. This method can be used to query compatibility. In order to ensure that the setup and running of an export operation will succeed using a given preset no significant changes (such as adding or deleting tracks) should be made to the asset between retrieving compatible identifiers and performing the export operation. @param presetName An NSString specifying the name of the preset template for the export. @param asset An AVAsset object that is intended to be exported. @param outputFileType An AVFileType indicating a file type to check; or nil, to query whether there are any compatible types. @param handler A block called with the compatibility result.
      */
-    static determineCompatibilityOfExportPreset$withAsset$outputFileType$completionHandler$(presetName: _NSString, asset: _AVAsset, outputFileType: _NSString | null, handler: NobjcObject): void;
+    static determineCompatibilityOfExportPreset$withAsset$outputFileType$completionHandler$(presetName: _NSString, asset: _AVAsset, outputFileType: _NSString | null, handler: (compatible: boolean) => void): void;
     /**
      * @method initWithAsset:presetName: @abstract Initialize an AVAssetExportSession with the specified preset and set the source to the contents of the asset. @param asset An AVAsset object that is intended to be exported. @param presetName An NSString specifying the name of the preset template for the export. @result Returns the initialized AVAssetExportSession. @discussion If the specified asset belongs to a mutable subclass of AVAsset, AVMutableComposition or AVMutableMovie, the results of any export-related operation are undefined if you mutate the asset after the operation commences. These operations include but are not limited to: 1) testing the compatibility of export presets with the asset, 2) calculating the maximum duration or estimated length of the output file, and 3) the export operation itself.
      */
@@ -43,7 +42,7 @@ export declare class _AVAssetExportSession extends _NSObject {
      * @method exportAsynchronouslyWithCompletionHandler: @abstract Starts the asynchronous execution of an export session. @param handler If internal preparation for export fails, the handler will be invoked synchronously. The handler may also be called asynchronously after -exportAsynchronouslyWithCompletionHandler: returns, in the following cases: 1) if a failure occurs during the export, including failures of loading, re-encoding, or writing media data to the output, 2) if -cancelExport is invoked, 3) if export session succeeds, having completely written its output to the outputURL. In each case, AVAssetExportSession.status will signal the terminal state of the asset reader, and if a failure occurs, the NSError that describes the failure can be obtained from the error property. @discussion Initiates an asynchronous export operation and returns immediately.
      * @deprecated export(to:as:) async throws
      */
-    exportAsynchronouslyWithCompletionHandler$(handler: NobjcObject): void;
+    exportAsynchronouslyWithCompletionHandler$(handler: () => void): void;
     /**
      * @method cancelExport @abstract Cancels the execution of an export session. @discussion Cancel can be invoked when the export is running.
      * @deprecated Use Task.cancel() instead
@@ -52,15 +51,15 @@ export declare class _AVAssetExportSession extends _NSObject {
     /**
      * @method determineCompatibleFileTypesWithCompletionHandler: @abstract Performs an inspection on the AVAsset and Preset the object was initialized with to determine a list of file types the ExportSession can write. @param handler Called when the inspection completes with an array of file types the ExportSession can write. Note that this may have a count of zero. @discussion This method is different than the supportedFileTypes property in that it performs an inspection of the AVAsset in order to determine its compatibility with each of the session's supported file types.
      */
-    determineCompatibleFileTypesWithCompletionHandler$(handler: NobjcObject): void;
+    determineCompatibleFileTypesWithCompletionHandler$(handler: (compatibleFileTypes: _NSArray) => void): void;
     /**
      * @method estimateMaximumDurationWithCompletionHandler: @abstract Starts the asynchronous execution of estimating the maximum duration of the export based on the asset, preset, and fileLengthLimit associated with the export session. @discussion If fileLengthLimit is not set on the export session, fileLengthLimit will be assumed to be the maximum file size specified by the preset (if any); else infinite. @param handler A block called with the estimated maximum duration, or kCMTimeInvalid if an error occurs. The error parameter will be non-nil if an error occurs.
      */
-    estimateMaximumDurationWithCompletionHandler$(handler: NobjcObject | null): void;
+    estimateMaximumDurationWithCompletionHandler$(handler: ((estimatedMaximumDuration: CMTime, error: _NSError) => void) | null): void;
     /**
      * @method estimateOutputFileLengthWithCompletionHandler: @abstract Starts the asynchronous execution of estimating the output file length of the export based on the asset, preset, and timeRange associated with the export session. @discussion If timeRange is not set on the export session, timeRange will be assumed to be the full time range of the asset. @param handler A block called with the estimated output file length in bytes, if it can be determined; 0 otherwise. The error parameter will be non-nil if an error occurs.
      */
-    estimateOutputFileLengthWithCompletionHandler$(handler: NobjcObject | null): void;
+    estimateOutputFileLengthWithCompletionHandler$(handler: ((estimatedOutputFileLength: number, error: _NSError) => void) | null): void;
     /** Indicates the name of the preset with which the AVExportSession was initialized */
     presetName(): _NSString;
     /**

package/dist/AVFoundation/AVAssetImageGenerator.d.ts

@@ -1,5 +1,6 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSError } from "../Foundation/NSError.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVAsset } from "./AVAsset.js";
 import type { _AVVideoCompositing } from "./AVVideoCompositing.js";
@@ -8,6 +9,7 @@ import type { CGSize } from "../structs/CGSize.js";
 import type { CMTime } from "../structs/CMTime.js";
 import type { AVAssetImageGeneratorApertureMode } from "./AVAssetImageGeneratorApertureMode.js";
 import type { AVAssetImageGeneratorDynamicRangePolicy } from "./AVAssetImageGeneratorDynamicRangePolicy.js";
+import type { AVAssetImageGeneratorResult } from "./AVAssetImageGeneratorResult.js";
 export declare class _AVAssetImageGenerator extends _NSObject {
     static alloc(): _AVAssetImageGenerator;
     static new(): _AVAssetImageGenerator;
@@ -28,11 +30,11 @@ export declare class _AVAssetImageGenerator extends _NSObject {
     /**
      * Returns a series of CGImageRefs for an asset at or near the specified times. An NSArray of NSValues, each containing a CMTime, specifying the asset times at which an image is requested. A block that will be called when an image request is complete. Employs an efficient "batch mode" for getting images in time order. The client will receive exactly one handler callback for each requested time in requestedTimes. Changes to generator properties (snap behavior, maximum size, etc...) will not affect outstanding asynchronous image generation requests. The generated image is not retained. Clients should retain the image if they wish it to persist after the completion handler returns.
      */
-    generateCGImagesAsynchronouslyForTimes$completionHandler$(requestedTimes: _NSArray, handler: NobjcObject): void;
+    generateCGImagesAsynchronouslyForTimes$completionHandler$(requestedTimes: _NSArray, handler: (arg0: CMTime, arg1: NobjcObject, arg2: CMTime, arg3: AVAssetImageGeneratorResult, arg4: _NSError) => void): void;
     /**
      * Returns a CGImageRef for an asset at or near the specified time. A CMTime, specifying the asset time at which an image is requested. A block that will be called when the image request is complete. The client will receive exactly one handler callback for requestedTime. Changes to generator properties (snap behavior, maximum size, etc...) will not affect outstanding asynchronous image generation requests. The generated image is not retained. Clients should retain the image if they wish it to persist after the completion handler returns. If image generation succeeds, the `image` parameter to the completion handler will be non-NULL and the `error` parameter will be nil. If image generation fails or was cancelled, the `image` parameter will be NULL and the `error` parameter will describe what went wrong. For cancelled images, the returned error will be AVErrorOperationCancelled.
      */
-    generateCGImageAsynchronouslyForTime$completionHandler$(requestedTime: CMTime, handler: NobjcObject | null): void;
+    generateCGImageAsynchronouslyForTime$completionHandler$(requestedTime: CMTime, handler: ((image: NobjcObject, actualTime: CMTime, error: _NSError) => void) | null): void;
     /**
      * Cancels all outstanding image generation requests. Calls the handler block with AVAssetImageGeneratorCancelled for each image time in every previous invocation of -generateCGImagesAsynchronouslyForTimes:completionHandler: for which images have not yet been supplied.
      */

package/dist/AVFoundation/AVAssetPlaybackAssistant.d.ts

@@ -1,4 +1,4 @@
-import type { NobjcObject } from "objc-js";
+import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVAsset } from "./AVAsset.js";
 export declare class _AVAssetPlaybackAssistant extends _NSObject {
@@ -12,5 +12,5 @@ export declare class _AVAssetPlaybackAssistant extends _NSObject {
     /**
      * Calls the completionHandler with information about the asset. completionHandler is called when all of the AVAssetPlaybackConfigurationOption values have been loaded. If AVAssetPlaybackAssistant encounters failures when inspecting the contents of the asset, it will return no AVAssetPlaybackConfigurationOptions associated with those contents. - Parameter completionHandler: Called with an array of AVAssetPlaybackConfigurationOption values describing capabilities of the asset.
      */
-    loadPlaybackConfigurationOptionsWithCompletionHandler$(completionHandler: NobjcObject): void;
+    loadPlaybackConfigurationOptionsWithCompletionHandler$(completionHandler: (playbackConfigurationOptions: _NSArray) => void): void;
 }