objcjs-types 0.1.0 → 0.2.1

package/dist/AVFAudio/AVAudioSequencer.d.ts

@@ -19,19 +19,19 @@ export declare class _AVAudioSequencer extends _NSObject {
     /**
      * Load the file referenced by the URL and add the events to the sequence the URL to the file determines how the file's contents are mapped to tracks inside the sequence on exit, if an error occurs, a description of the error
      */
-    loadFromURL$options$error$(fileURL: _NSURL, options: AVMusicSequenceLoadOptions, outError: NobjcObject): boolean;
+    loadFromURL$options$error$(fileURL: _NSURL, options: AVMusicSequenceLoadOptions, outError: NobjcObject | null): boolean;
     /**
      * Parse the data and add the its events to the sequence the data to load from determines how the contents are mapped to tracks inside the sequence on exit, if an error occurs, a description of the error
      */
-    loadFromData$options$error$(data: _NSData, options: AVMusicSequenceLoadOptions, outError: NobjcObject): boolean;
+    loadFromData$options$error$(data: _NSData, options: AVMusicSequenceLoadOptions, outError: NobjcObject | null): boolean;
     /**
      * Create and write a MIDI file containing the events and complete state of the sequence the path for the file to be created the relationship between "tick" and quarter note for saving to a Standard MIDI File - pass in zero to use default - this will be the value that is currently set on the tempo track if the file already exists, YES will cause it to be overwritten with the new data. Otherwise the call will fail with a permission error. on exit, if an error occurs, a description of the error A MIDI file saved via this method will contain not only the complete MIDI content of the sequence, but also the state of all tracks, including muting, loop points and enablement, etc. It will also contain all non-MIDI AVMusicEvent types which had been added to the sequence's track. MIDI files are normally beat based, but can also have a SMPTE (or real-time rather than beat time) representation. The relationship between "tick" and quarter note for saving to Standard MIDI File - pass in zero to use default - this will be the value that is currently set on the tempo track
      */
-    writeToURL$SMPTEResolution$replaceExisting$error$(fileURL: _NSURL, resolution: number, replace: boolean, outError: NobjcObject): boolean;
+    writeToURL$SMPTEResolution$replaceExisting$error$(fileURL: _NSURL, resolution: number, replace: boolean, outError: NobjcObject | null): boolean;
     /**
      * Return a data object containing the events from the sequence All details regarding the SMPTE resolution apply here as well. The returned NSData lifetime is controlled by the client.
      */
-    dataWithSMPTEResolution$error$(SMPTEResolution: number, outError: NobjcObject): _NSData;
+    dataWithSMPTEResolution$error$(SMPTEResolution: number, outError: NobjcObject | null): _NSData;
     /**
      * Get the time in seconds for the given beat position (timestamp) in the AVMusicTrack
      */
@@ -49,15 +49,15 @@ 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: number | null): void;
+    setUserCallback$(userCallback: NobjcObject | 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.
      */
-    hostTimeForBeats$error$(inBeats: number, outError: NobjcObject): number;
+    hostTimeForBeats$error$(inBeats: number, outError: NobjcObject | null): number;
     /**
      * Returns the beat that will be (or was) played at the specified host time. 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 time of the player was after the specified host time. The method uses the sequence's tempo map to retrieve a beat time from the starting and specified host time.
      */
-    beatsForHostTime$error$(inHostTime: number, outError: NobjcObject): number;
+    beatsForHostTime$error$(inHostTime: number, outError: NobjcObject | null): number;
     /**
      * Get ready to play the sequence by prerolling all events Happens automatically on play if it has not already been called, but may produce a delay in startup.
      */
@@ -65,7 +65,7 @@ export declare class _AVAudioSequencer extends _NSObject {
     /**
      * Start the sequencer's player If the AVAudioSequencer has not been prerolled, it will pre-roll itself and then start. When the sequencer is associated with an audio engine, the sequencer's player will only play if the audio engine is running.
      */
-    startAndReturnError$(outError: NobjcObject): boolean;
+    startAndReturnError$(outError: NobjcObject | null): boolean;
     /**
      * Stop the sequencer's player Stopping the player leaves it in an un-prerolled state, but stores the playback position so that a subsequent call to startAndReturnError will resume where it left off. This action will not stop an associated audio engine.
      */

package/dist/AVFAudio/AVAudioSession.d.ts

@@ -29,27 +29,27 @@ export declare class _AVAudioSession extends _NSObject {
      */
     init(): _AVAudioSession;
     /** @deprecated -setActive:withOptions:error: */
-    setActive$withFlags$error$(active: boolean, flags: number, outError: NobjcObject): boolean;
+    setActive$withFlags$error$(active: boolean, flags: number, outError: NobjcObject | null): boolean;
     /** @deprecated setPreferredSampleRate:error: */
-    setPreferredHardwareSampleRate$error$(sampleRate: number, outError: NobjcObject): boolean;
+    setPreferredHardwareSampleRate$error$(sampleRate: number, outError: NobjcObject | null): boolean;
     /** Set session category. */
-    setCategory$error$(category: AVAudioSessionCategory, outError: NobjcObject): boolean;
+    setCategory$error$(category: AVAudioSessionCategory, outError: NobjcObject | null): boolean;
     /** Set session category with options. */
-    setCategory$withOptions$error$(category: AVAudioSessionCategory, options: AVAudioSessionCategoryOptions, outError: NobjcObject): boolean;
+    setCategory$withOptions$error$(category: AVAudioSessionCategory, options: AVAudioSessionCategoryOptions, outError: NobjcObject | null): boolean;
     /** Set session category and mode with options. */
-    setCategory$mode$options$error$(category: AVAudioSessionCategory, mode: AVAudioSessionMode, options: AVAudioSessionCategoryOptions, outError: NobjcObject): boolean;
+    setCategory$mode$options$error$(category: AVAudioSessionCategory, mode: AVAudioSessionMode, options: AVAudioSessionCategoryOptions, outError: NobjcObject | null): boolean;
     /**
      * Set session category, mode, routing sharing policy, and options. Use of the long-form route sharing policy is only valid in conjunction with a limited set of category, mode, and option values. Allowed categories: AVAudioSessionCategoryPlayback. Allowed modes: AVAudioSessionModeDefault, AVAudioSessionModeMoviePlayback, AVAudioSessionModeSpokenAudio. Allowed options: None. Options are allowed when changing the routing policy back to Default, however.
      */
-    setCategory$mode$routeSharingPolicy$options$error$(category: AVAudioSessionCategory, mode: AVAudioSessionMode, policy: AVAudioSessionRouteSharingPolicy, options: AVAudioSessionCategoryOptions, outError: NobjcObject): boolean;
+    setCategory$mode$routeSharingPolicy$options$error$(category: AVAudioSessionCategory, mode: AVAudioSessionMode, policy: AVAudioSessionRouteSharingPolicy, options: AVAudioSessionCategoryOptions, outError: NobjcObject | null): boolean;
     /**
      * Set the session's mode. Modes modify the audio category in order to introduce behavior that is tailored to the specific use of audio within an application. Examples: AVAudioSessionModeVideoRecording, AVAudioSessionModeVoiceChat, AVAudioSessionModeMeasurement, etc.
      */
-    setMode$error$(mode: AVAudioSessionMode, outError: NobjcObject): boolean;
+    setMode$error$(mode: AVAudioSessionMode, outError: NobjcObject | null): boolean;
     /**
      * Set allowHapticsAndSystemSoundsDuringRecording to YES in order to allow system sounds and haptics to play while the session is actively using audio input. Default value is NO.
      */
-    setAllowHapticsAndSystemSoundsDuringRecording$error$(inValue: boolean, outError: NobjcObject): boolean;
+    setAllowHapticsAndSystemSoundsDuringRecording$error$(inValue: boolean, outError: NobjcObject | null): boolean;
     /**
      * 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
@@ -58,80 +58,80 @@ export declare class _AVAudioSession extends _NSObject {
     /**
      * 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.
      */
-    overrideOutputAudioPort$error$(portOverride: AVAudioSessionPortOverride, outError: NobjcObject): boolean;
+    overrideOutputAudioPort$error$(portOverride: AVAudioSessionPortOverride, outError: NobjcObject | null): boolean;
     /**
      * Select a preferred input port for audio routing. If the input port is already part of the current audio route, this will have no effect. Otherwise, selecting an input port for routing will initiate a route change to use the preferred input port. Setting a nil value will clear the preference.
      */
-    setPreferredInput$error$(inPort: _AVAudioSessionPortDescription | null, outError: NobjcObject): boolean;
+    setPreferredInput$error$(inPort: _AVAudioSessionPortDescription | null, outError: NobjcObject | null): boolean;
     /**
      * Set ringtone and alert interruption preference. Inform the system when the session prefers to not be interrupted by ringtones and alerts. By setting this property to YES, clients will not be interrupted by incoming call notifications and other alerts. Starting in iOS 14.0, users can set a global preference for incoming call display style to "Banner" or "Full Screen". With "Banner" display style, if below property is set to YES then system audio will be silenced. Thus, clients will not be interrupted on incoming call notification and user will have opportunity to accept or decline the call. If call is declined, the session will not be interrupted, but if user accepts the incoming call, the session will be interrupted. With display style set as "Full Screen", below property will have no effect and clients will be interrupted by incoming calls. Apps that record audio and/or video and apps that are used for music performance are candidates for using this feature.
      */
-    setPrefersNoInterruptionsFromSystemAlerts$error$(inValue: boolean, outError: NobjcObject): boolean;
+    setPrefersNoInterruptionsFromSystemAlerts$error$(inValue: boolean, outError: NobjcObject | null): boolean;
     /**
      * Set a preference to enable echo cancelled input on supported hardware Applications might want to record the built-in microphone's input while also playing audio out via the built-in speaker. Enabling echo cancelled input is useful when the application needs the input signal to be clear of any echoes from the audio playing out of the built-in speaker. Audio sessions using Voice Processor don't need this option as echo cancellation is implicitly applied for those routes. The Voice Processor solution is tuned for voice signals, unlike this option, which is tuned for better capture of wider range of audio signals in the presence of built-in speaker echo. This option is only available on certain 2024 or later iPhone models and is valid only when used with the following configurations: - AVAudioSessionCategoryPlayAndRecord and AVAudioSessionModeDefault - AVAudioSessionCategoryMultiRoute and AVAudioSessionModeDualRoute Support can be queried using property `isEchoCancelledInputAvailable`. Other recording sessions might be interrupted if this option is not compatible with sessions that are already recording. After an audio session goes active, `isEchoCancelledInputEnabled` property can be queried to check if the option was honored. Note that the enabled state may change after route changes, e.g. if user plugs in a headset, that route might not support echo cancellation.
      */
-    setPrefersEchoCancelledInput$error$(value: boolean, error: NobjcObject): boolean;
+    setPrefersEchoCancelledInput$error$(value: boolean, error: NobjcObject | null): boolean;
     /**
      * Sets a Boolean value to inform the system to mute the session's output audio. The default value is false (unmuted). This property is supported with all categories and modes, except for ``AVAudioSessionCategoryPlayAndRecord`` where it is only supported with ``AVAudioSessionModeDefault``. Changing the mode to non-default mode with ``AVAudioSessionCategoryPlayAndRecord`` category will cause the session to unmute. Changes in output mute state can be observed via ``AVAudioSessionOutputMuteStateChangeNotification``. If this value is set to true, ``AVAudioSessionUserIntentToUnmuteOutputNotification`` may be sent when a user hints to unmute by changing the volume. - Note: This will not mute system sounds and haptics. - Parameters: - `muted`: A Boolean value to set the audio output to the desired muted state. - `error`: A pointer to an error object. If an error occurs, the framework sets the pointer to an error object that describes the failure.
      */
-    setOutputMuted$error$(muted: boolean, outError: NobjcObject): boolean;
+    setOutputMuted$error$(muted: boolean, outError: NobjcObject | null): boolean;
     /**
      * Set the session active or inactive. Note that activating an audio session is a synchronous (blocking) operation. Therefore, we recommend that applications not activate their session from a thread where a long blocking operation will be problematic. Apps may activate a AVAudioSessionCategoryPlayback session when another app is hosting a call (to start a SharePlay activity for example). However, they are not permitted to capture the microphone of the active call, so attempts to activate a session with category AVAudioSessionCategoryRecord or AVAudioSessionCategoryPlayAndRecord will fail with error AVAudioSessionErrorCodeInsufficientPriority. When deactivating a session, the caller is required to first stop or pause all running I/Os (e.g. audio queues, players, recorders, converters, remote I/Os, etc.). Starting in iOS 8, if the session has running I/Os at the time that deactivation is requested, the session will be deactivated, but the method will return NO and populate the NSError with the code property set to AVAudioSessionErrorCodeIsBusy to indicate the misuse of the API. Prior to iOS 8, the session would have remained active if it had running I/Os at the time of the deactivation request. Starting in iOS 26.0, deactivating while IO is running will no longer return AVAudioSessionErrorCodeIsBusy.
      */
-    setActive$error$(active: boolean, outError: NobjcObject): boolean;
-    setActive$withOptions$error$(active: boolean, options: AVAudioSessionSetActiveOptions, outError: NobjcObject): boolean;
+    setActive$error$(active: boolean, outError: NobjcObject | null): boolean;
+    setActive$withOptions$error$(active: boolean, options: AVAudioSessionSetActiveOptions, outError: NobjcObject | null): boolean;
     /**
      * 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): void;
+    activateWithOptions$completionHandler$(options: AVAudioSessionActivationOptions, handler: NobjcObject | null): void;
     /**
      * The preferred hardware sample rate for the session. The actual sample rate may be different.
      */
-    setPreferredSampleRate$error$(sampleRate: number, outError: NobjcObject): boolean;
+    setPreferredSampleRate$error$(sampleRate: number, outError: NobjcObject | null): boolean;
     /**
      * The preferred hardware IO buffer duration in seconds. The actual IO buffer duration may be different.
      */
-    setPreferredIOBufferDuration$error$(duration: number, outError: NobjcObject): boolean;
+    setPreferredIOBufferDuration$error$(duration: number, outError: NobjcObject | null): boolean;
     /**
      * Sets the number of input channels that the app would prefer for the current route
      */
-    setPreferredInputNumberOfChannels$error$(count: number, outError: NobjcObject): boolean;
+    setPreferredInputNumberOfChannels$error$(count: number, outError: NobjcObject | null): boolean;
     /**
      * Sets the number of output channels that the app would prefer for the current route
      */
-    setPreferredOutputNumberOfChannels$error$(count: number, outError: NobjcObject): boolean;
+    setPreferredOutputNumberOfChannels$error$(count: number, outError: NobjcObject | null): boolean;
     /**
      * Sets the preferred input orientation. The input orientation determines which directions will be left and right when a built-in mic data source with the AVAudioSessionPolarPatternStereo polar pattern is selected. Typically, this orientation should match how the user is holding the device while recording, which will match the application's interface orientation when a single app is on the screen. The actual input orientation may be different, for example, if another app's session is in control of routing. The input orientation is independent of the orientation property of an AVAudioSessionDataSourceDescription.
      */
-    setPreferredInputOrientation$error$(orientation: AVAudioStereoOrientation, outError: NobjcObject): boolean;
+    setPreferredInputOrientation$error$(orientation: AVAudioStereoOrientation, outError: NobjcObject | null): boolean;
     /**
      * A value defined over the range [0.0, 1.0], with 0.0 corresponding to the lowest analog gain setting and 1.0 corresponding to the highest analog gain setting. Attempting to set values outside of the defined range will result in the value being "clamped" to a valid input. This is a global input gain setting that applies to the current input source for the entire system. When no applications are using the input gain control, the system will restore the default input gain setting for the input source. Note that some audio accessories, such as USB devices, may not have a default value. This property is only valid if inputGainSettable is true. Note: inputGain is key-value observable.
      */
-    setInputGain$error$(gain: number, outError: NobjcObject): boolean;
+    setInputGain$error$(gain: number, outError: NobjcObject | null): boolean;
     /**
      * Select a new input data source. Setting a nil value will clear the data source preference.
      */
-    setInputDataSource$error$(dataSource: _AVAudioSessionDataSourceDescription | null, outError: NobjcObject): boolean;
+    setInputDataSource$error$(dataSource: _AVAudioSessionDataSourceDescription | null, outError: NobjcObject | null): boolean;
     /**
      * Select a new output data source. Setting a nil value will clear the data source preference.
      */
-    setOutputDataSource$error$(dataSource: _AVAudioSessionDataSourceDescription | null, outError: NobjcObject): boolean;
+    setOutputDataSource$error$(dataSource: _AVAudioSessionDataSourceDescription | null, outError: NobjcObject | null): boolean;
     /**
      * Controls whether audio input and output are aggregated. Only valid in combination with AVAudioSessionCategoryPlayAndRecord or AVAudioSessionCategoryMultiRoute. See the AVAudioSessionIOType documentation for a more detailed explanation of why a client may want to change the IO type.
      */
-    setAggregatedIOPreference$error$(inIOType: AVAudioSessionIOType, outError: NobjcObject): boolean;
+    setAggregatedIOPreference$error$(inIOType: AVAudioSessionIOType, outError: NobjcObject | null): boolean;
     /**
      * Set YES to inform the system if the app can supply multichannel audio content. Default value is NO. This property is intended to be used by 'Now Playing' applications. See https://developer.apple.com/documentation/mediaplayer/becoming_a_now_playable_app for more information about what it means to be a 'Now Playing' application. Typically 'Now Playing' applications will also use AVAudioSessionRouteSharingPolicyLongFormAudio or AVAudioSessionRouteSharingPolicyLongFormVideo.
      */
-    setSupportsMultichannelContent$error$(inValue: boolean, outError: NobjcObject): boolean;
+    setSupportsMultichannelContent$error$(inValue: boolean, outError: NobjcObject | null): boolean;
     /**
      * Use this method to opt in or opt out of interruption on route disconnect policy. As described in the Audio Session Programming Guide, most media playback apps are expected to pause playback if the route change reason is AVAudioSessionRouteChangeReasonOldDeviceUnavailable. Starting in iOS 17, by default Now Playing sessions will be interrupted if they are active when a route change occurs because of a disconnect event. All other sessions will not be interrupted due to a disconnect event.
      */
-    setPrefersInterruptionOnRouteDisconnect$error$(inValue: boolean, outError: NobjcObject): boolean;
+    setPrefersInterruptionOnRouteDisconnect$error$(inValue: boolean, outError: NobjcObject | null): boolean;
     /**
      * Set the preferred form of audio injection into another app's input stream See AVAudioSessionMicrophoneInjectionMode for available modes
      */
-    setPreferredMicrophoneInjectionMode$error$(inValue: AVAudioSessionMicrophoneInjectionMode, outError: NobjcObject): boolean;
+    setPreferredMicrophoneInjectionMode$error$(inValue: AVAudioSessionMicrophoneInjectionMode, outError: NobjcObject | null): boolean;
     /**
      * For example: [[NSNotificationCenter defaultCenter] addObserver: myObject selector: @selector(handleInterruption:) name: AVAudioSessionInterruptionNotification object: [AVAudioSession sharedInstance]];
      * @deprecated No longer supported

package/dist/AVFAudio/AVAudioSessionChannelDescription.d.ts

@@ -1,4 +1,3 @@
-import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _NSString } from "../Foundation/NSString.js";
 export declare class _AVAudioSessionChannelDescription extends _NSObject {
@@ -12,5 +11,5 @@ export declare class _AVAudioSessionChannelDescription extends _NSObject {
     /** The index of this channel in its owning port's array of channels. */
     channelNumber(): number;
     /** Description of the physical location of this channel. */
-    channelLabel(): NobjcObject;
+    channelLabel(): number;
 }

package/dist/AVFAudio/AVAudioSessionDataSourceDescription.d.ts

@@ -13,7 +13,7 @@ export declare class _AVAudioSessionDataSourceDescription extends _NSObject {
     /**
      * @brief Select the desired polar pattern from the set of available patterns. Setting a nil value will clear the preference. @note If the owning port and data source are part of the active audio route, changing the polar pattern will likely result in a route reconfiguration. If the owning port and data source are not part of the active route, selecting a polar pattern will not result in an immediate route reconfiguration. Use AVAudioSession's setPreferredInput:error: method to activate the port. Use setPreferredDataSource:error: to active the data source on the port. You must call setPreferredInputOrientation:error: on the AVAudioSession if you chose the AVAudioSessionPolarPatternStereo polar pattern.
      */
-    setPreferredPolarPattern$error$(pattern: AVAudioSessionPolarPattern | null, outError: NobjcObject): boolean;
+    setPreferredPolarPattern$error$(pattern: AVAudioSessionPolarPattern | null, outError: NobjcObject | null): boolean;
     /** System-assigned ID for the data source. */
     dataSourceID(): _NSNumber;
     /** Human-readable name for the data source. */

package/dist/AVFAudio/AVAudioSessionPortDescription.d.ts

@@ -12,7 +12,7 @@ export declare class _AVAudioSessionPortDescription extends _NSObject {
     /**
      * @brief Select the preferred data source for this port. The input dataSource parameter must be one of the dataSources exposed by the dataSources property. Setting a nil value will clear the preference. Note: if the port is part of the active audio route, changing the data source will likely result in a route reconfiguration. If the port is not part of the active route, selecting a new data source will not result in an immediate route reconfiguration. Use AVAudioSession's -setPreferredInput:error: method to activate the port.
      */
-    setPreferredDataSource$error$(dataSource: _AVAudioSessionDataSourceDescription | null, outError: NobjcObject): boolean;
+    setPreferredDataSource$error$(dataSource: _AVAudioSessionDataSourceDescription | null, outError: NobjcObject | null): boolean;
     portType(): AVAudioSessionPort;
     /** A descriptive name for the associated hardware port */
     portName(): _NSString;

package/dist/AVFAudio/AVAudioSinkNode.d.ts

@@ -1,3 +1,4 @@
+import type { NobjcObject } from "objc-js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
 export declare class _AVAudioSinkNode extends _AVAudioNode {
     static alloc(): _AVAudioSinkNode;
@@ -6,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: number): _AVAudioSinkNode;
+    initWithReceiverBlock$(block: NobjcObject): _AVAudioSinkNode;
 }

package/dist/AVFAudio/AVAudioSourceNode.d.ts

@@ -1,4 +1,6 @@
+import type { NobjcObject } from "objc-js";
 import type { _AVAudioFormat } from "./AVAudioFormat.js";
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
 export declare class _AVAudioSourceNode extends _AVAudioNode {
     static alloc(): _AVAudioSourceNode;
@@ -7,9 +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: number): _AVAudioSourceNode;
+    initWithRenderBlock$(block: NobjcObject): _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: number): _AVAudioSourceNode;
+    initWithFormat$renderBlock$(format: _AVAudioFormat, block: NobjcObject): _AVAudioSourceNode;
+}
+export interface _AVAudioSourceNode extends _AVAudioMixing {
 }

package/dist/AVFAudio/AVAudioUnit.d.ts

@@ -11,11 +11,11 @@ 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): void;
+    static instantiateWithComponentDescription$options$completionHandler$(audioComponentDescription: AudioComponentDescription, options: NobjcObject, completionHandler: NobjcObject | 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.
      */
-    loadAudioUnitPresetAtURL$error$(url: _NSURL, outError: NobjcObject): boolean;
+    loadAudioUnitPresetAtURL$error$(url: _NSURL, outError: NobjcObject | null): boolean;
     /**
      * @property audioComponentDescription @abstract AudioComponentDescription of the underlying audio unit.
      */

package/dist/AVFAudio/AVAudioUnitGenerator.d.ts

@@ -1,3 +1,4 @@
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioUnit } from "./AVAudioUnit.js";
 import type { AudioComponentDescription } from "../structs/AudioComponentDescription.js";
 export declare class _AVAudioUnitGenerator extends _AVAudioUnit {
@@ -12,3 +13,5 @@ export declare class _AVAudioUnitGenerator extends _AVAudioUnit {
     bypass(): boolean;
     setBypass$(value: boolean): void;
 }
+export interface _AVAudioUnitGenerator extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioUnitMIDIInstrument.d.ts

@@ -1,4 +1,5 @@
 import type { NobjcObject } from "objc-js";
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioUnit } from "./AVAudioUnit.js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { AudioComponentDescription } from "../structs/AudioComponentDescription.js";
@@ -59,3 +60,5 @@ export declare class _AVAudioUnitMIDIInstrument extends _AVAudioUnit {
      */
     sendMIDIEventList$(eventList: NobjcObject): void;
 }
+export interface _AVAudioUnitMIDIInstrument extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioUnitSampler.d.ts

@@ -9,15 +9,15 @@ export declare class _AVAudioUnitSampler extends _AVAudioUnitMIDIInstrument {
     /**
      * loads a specific instrument from the specified sound bank URL for a Soundbank file. The file can be either a DLS bank (.dls) or a SoundFont bank (.sf2). program number for the instrument to load MSB for the bank number for the instrument to load. This is usually 0x79 for melodic instruments and 0x78 for percussion instruments. LSB for the bank number for the instrument to load. This is often 0, and represents the "bank variation". the status of the operation This method reads from file and allocates memory, so it should not be called on a real time thread.
      */
-    loadSoundBankInstrumentAtURL$program$bankMSB$bankLSB$error$(bankURL: _NSURL, program: number, bankMSB: number, bankLSB: number, outError: NobjcObject): boolean;
+    loadSoundBankInstrumentAtURL$program$bankMSB$bankLSB$error$(bankURL: _NSURL, program: number, bankMSB: number, bankLSB: number, outError: NobjcObject | null): boolean;
     /**
      * configures the sampler by loading the specified preset file. URL to the preset file or audio file the status of the operation The file can be of one of the following types: Logic/GarageBand EXS24 instrument, the Sampler AU's native aupreset, or an audio file (eg. .caf, .aiff, .wav, .mp3). If an audio file URL is loaded, it will become the sole sample in a new default instrument. Any information contained in the file regarding its keyboard placement (e.g. root key, key range) will be used. This method reads from file and allocates memory, so it should not be called on a real time thread.
      */
-    loadInstrumentAtURL$error$(instrumentURL: _NSURL, outError: NobjcObject): boolean;
+    loadInstrumentAtURL$error$(instrumentURL: _NSURL, outError: NobjcObject | null): boolean;
     /**
      * configures the sampler by loading a set of audio files. array of URLs for audio files to be loaded the status of the operation The audio files are loaded into a new default instrument with each audio file placed into its own sampler zone. Any information contained in the audio file regarding their placement on the keyboard (e.g. root key, key range) will be used. This method reads from file and allocates memory, so it should not be called on a real time thread.
      */
-    loadAudioFilesAtURLs$error$(audioFiles: _NSArray, outError: NobjcObject): boolean;
+    loadAudioFilesAtURLs$error$(audioFiles: _NSArray, outError: NobjcObject | null): boolean;
     /** adjusts the pan for all the notes played. Range: -100 -> +100 Default: 0 */
     stereoPan(): number;
     setStereoPan$(value: number): void;

package/dist/AVFAudio/AVMIDIPlayer.d.ts

@@ -9,17 +9,17 @@ export declare class _AVMIDIPlayer extends _NSObject {
     /**
      * Create a player with the contents of the file specified by the URL. 'bankURL' should contain the path to a SoundFont2 or DLS bank to be used by the MIDI synthesizer. For OSX it can be set to nil for the default, but for iOS it must always refer to a valid bank file.
      */
-    initWithContentsOfURL$soundBankURL$error$(inURL: _NSURL, bankURL: _NSURL | null, outError: NobjcObject): _AVMIDIPlayer | null;
+    initWithContentsOfURL$soundBankURL$error$(inURL: _NSURL, bankURL: _NSURL | null, outError: NobjcObject | null): _AVMIDIPlayer | null;
     /**
      * Create a player with the contents of the data object 'bankURL' should contain the path to a SoundFont2 or DLS bank to be used by the MIDI synthesizer. For OSX it can be set to nil for the default, but for iOS it must always refer to a valid bank file.
      */
-    initWithData$soundBankURL$error$(data: _NSData, bankURL: _NSURL | null, outError: NobjcObject): _AVMIDIPlayer | null;
+    initWithData$soundBankURL$error$(data: _NSData, bankURL: _NSURL | null, outError: NobjcObject | null): _AVMIDIPlayer | null;
     /**
      * Get ready to play the sequence by prerolling all events Happens automatically on play if it has not already been called, but may produce a delay in startup.
      */
     prepareToPlay(): void;
     /** Play the sequence. */
-    play$(completionHandler: number | null): void;
+    play$(completionHandler: NobjcObject | 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: number): void;
+    enumerateEventsInRange$usingBlock$(range: AVBeatRange, block: NobjcObject): 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.
      */
@@ -43,8 +43,8 @@ export declare class _AVMusicTrack extends _NSObject {
     /**
      * @property destinationMIDIEndpoint @abstract Set the track's target to the specified MIDI endpoint @discussion This is mutually exclusive with setting a destination audio unit. Setting this will remove the track's reference to an AVAudioUnit destination. When played, the track will send its events to the MIDI Endpoint. See also MIDIDestinationCreate. The endpoint cannot be changed while the track's sequence is playing.
      */
-    destinationMIDIEndpoint(): NobjcObject;
-    setDestinationMIDIEndpoint$(value: NobjcObject): void;
+    destinationMIDIEndpoint(): number;
+    setDestinationMIDIEndpoint$(value: number): void;
     /**
      * The timestamp range in beats for the loop The loop is set by specifying its beat range.
      */

package/dist/AVFAudio/AVSpeechSynthesisMarker.d.ts

@@ -1,4 +1,6 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { NSRange } from "../structs/NSRange.js";
 import type { AVSpeechSynthesisMarkerMark } from "./AVSpeechSynthesisMarkerMark.js";
@@ -27,3 +29,5 @@ export declare class _AVSpeechSynthesisMarker extends _NSObject {
     phoneme(): _NSString;
     setPhoneme$(value: _NSString): void;
 }
+export interface _AVSpeechSynthesisMarker extends _NSSecureCoding, _NSCopying {
+}

package/dist/AVFAudio/AVSpeechSynthesisProviderAudioUnit.d.ts

@@ -1,3 +1,4 @@
+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";
@@ -19,6 +20,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(): number | null;
-    setSpeechSynthesisOutputMetadataBlock$(value: number | null): void;
+    speechSynthesisOutputMetadataBlock(): NobjcObject | null;
+    setSpeechSynthesisOutputMetadataBlock$(value: NobjcObject | null): void;
 }

package/dist/AVFAudio/AVSpeechSynthesisProviderRequest.d.ts

@@ -1,4 +1,6 @@
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVSpeechSynthesisProviderVoice } from "./AVSpeechSynthesisProviderVoice.js";
 export declare class _AVSpeechSynthesisProviderRequest extends _NSObject {
@@ -13,3 +15,5 @@ export declare class _AVSpeechSynthesisProviderRequest extends _NSObject {
     /** @abstract The voice to be used in this speech request */
     voice(): _AVSpeechSynthesisProviderVoice;
 }
+export interface _AVSpeechSynthesisProviderRequest extends _NSSecureCoding, _NSCopying {
+}

package/dist/AVFAudio/AVSpeechSynthesisProviderVoice.d.ts

@@ -1,5 +1,7 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { AVSpeechSynthesisVoiceGender } from "./AVSpeechSynthesisVoiceGender.js";
 export declare class _AVSpeechSynthesisProviderVoice extends _NSObject {
@@ -39,3 +41,5 @@ export declare class _AVSpeechSynthesisProviderVoice extends _NSObject {
     age(): number;
     setAge$(value: number): void;
 }
+export interface _AVSpeechSynthesisProviderVoice extends _NSSecureCoding, _NSCopying {
+}

package/dist/AVFAudio/AVSpeechSynthesisVoice.d.ts

@@ -1,6 +1,7 @@
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { AVSpeechSynthesisVoiceGender } from "./AVSpeechSynthesisVoiceGender.js";
 import type { AVSpeechSynthesisVoiceQuality } from "./AVSpeechSynthesisVoiceQuality.js";
@@ -30,3 +31,5 @@ export declare class _AVSpeechSynthesisVoice extends _NSObject {
     audioFileSettings(): _NSDictionary;
     voiceTraits(): AVSpeechSynthesisVoiceTraits;
 }
+export interface _AVSpeechSynthesisVoice extends _NSSecureCoding {
+}

package/dist/AVFAudio/AVSpeechSynthesizer.d.ts

@@ -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: number): void;
+    writeUtterance$toBufferCallback$(utterance: _AVSpeechUtterance, bufferCallback: NobjcObject): 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: number, markerCallback: number): void;
+    writeUtterance$toBufferCallback$toMarkerCallback$(utterance: _AVSpeechUtterance, bufferCallback: NobjcObject, markerCallback: NobjcObject): void;
     /** Call stopSpeakingAtBoundary: to interrupt current speech and clear the queue. */
     stopSpeakingAtBoundary$(boundary: AVSpeechBoundary): boolean;
     pauseSpeakingAtBoundary$(boundary: AVSpeechBoundary): boolean;

package/dist/AVFAudio/AVSpeechUtterance.d.ts

@@ -1,5 +1,7 @@
 import type { _NSAttributedString } from "../Foundation/NSAttributedString.js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _NSString } from "../Foundation/NSString.js";
 import type { _AVSpeechSynthesisVoice } from "./AVSpeechSynthesisVoice.js";
 export declare class _AVSpeechUtterance extends _NSObject {
@@ -46,3 +48,5 @@ export declare class _AVSpeechUtterance extends _NSObject {
     postUtteranceDelay(): number;
     setPostUtteranceDelay$(value: number): void;
 }
+export interface _AVSpeechUtterance extends _NSCopying, _NSSecureCoding {
+}