objcjs-types 0.1.0 → 0.2.1

package/README.md

@@ -21,7 +21,8 @@ Import frameworks by name:
 ```ts
 import { NSApplication, NSWindow, NSWindowStyleMask } from "objcjs-types/AppKit";
 import { NSString } from "objcjs-types/Foundation";
-import { CGRect, options } from "objcjs-types";
+import { CGRect } from "objcjs-types";
+import { options } from "objcjs-types/helpers";
 ```
 
 Create a window:
@@ -68,12 +69,51 @@ const delegate = createDelegate("NSWindowDelegate", {
 window.setDelegate$(delegate);
 ```
 
+### `instanceof` narrowing
+
+Class constants have `Symbol.hasInstance` patched so that `instanceof` works with ObjC objects, using the runtime's `isKindOfClass:` check:
+
+```ts
+import {
+  ASAuthorizationAppleIDCredential,
+  ASPasswordCredential,
+  type _ASAuthorization
+} from "objcjs-types/AuthenticationServices";
+
+declare const auth: _ASAuthorization;
+const cred = auth.credential();
+
+if (cred instanceof ASAuthorizationAppleIDCredential) {
+  cred.user(); // narrowed to _ASAuthorizationAppleIDCredential
+  cred.email();
+} else if (cred instanceof ASPasswordCredential) {
+  cred.user();
+  cred.password();
+}
+```
+
+There's also an `isKindOfClass` type guard for explicit narrowing with a generic type parameter:
+
+```ts
+import { isKindOfClass } from "objcjs-types/helpers";
+import {
+  ASAuthorizationAppleIDCredential,
+  type _ASAuthorizationAppleIDCredential
+} from "objcjs-types/AuthenticationServices";
+
+if (isKindOfClass<_ASAuthorizationAppleIDCredential>(cred, ASAuthorizationAppleIDCredential)) {
+  cred.user(); // narrowed
+}
+```
+
+Both `instanceof` and `isKindOfClass` cache results per (object, class) pair so repeated checks skip the native boundary.
+
 ### NS_OPTIONS
 
 Use `options()` to combine bitmask flags with type safety:
 
 ```ts
-import { options } from "objcjs-types";
+import { options } from "objcjs-types/helpers";
 import { NSWindowStyleMask } from "objcjs-types/AppKit";
 
 const mask = options(NSWindowStyleMask.Titled, NSWindowStyleMask.Closable, NSWindowStyleMask.Resizable);
@@ -93,14 +133,57 @@ const point: CGPoint = { x: 100, y: 200 };
 const size: CGSize = { width: 800, height: 600 };
 ```
 
-### Helpers
+### NSData conversion (`objcjs-types/nsdata`)
+
+Utilities for converting between NSData and JavaScript Buffers:
+
+```ts
+import { NSDataFromBuffer, bufferFromNSData, NSDataFromBase64, base64FromNSData } from "objcjs-types/nsdata";
+
+const nsData = NSDataFromBuffer(Buffer.from("hello"));
+const buffer = bufferFromNSData(nsData);
+const b64 = base64FromNSData(nsData);
+```
+
+### OS version detection (`objcjs-types/osversion`)
+
+Cached macOS version queries with named release constants:
 
 ```ts
-import { NSStringFromString } from "objcjs-types";
+import { getOSVersion, isAtLeast, macOS, formatVersion } from "objcjs-types/osversion";
+
+console.log(formatVersion(getOSVersion())); // "15.3.1"
 
-const nsStr = NSStringFromString("hello"); // NSString from JS string
+if (isAtLeast(macOS.Sequoia)) {
+  // Sequoia+ only APIs
+}
 ```
 
+### Helpers (`objcjs-types/helpers`)
+
+```ts
+import {
+  NSStringFromString,
+  NSArrayFromObjects,
+  NSDictionaryFromKeysAndValues,
+  options,
+  isKindOfClass
+} from "objcjs-types/helpers";
+
+const nsStr = NSStringFromString("hello");
+```
+
+## Subpath exports
+
+| Import path                | Contents                                               |
+| -------------------------- | ------------------------------------------------------ |
+| `objcjs-types`             | Structs, `createDelegate`, barrel re-exports           |
+| `objcjs-types/helpers`     | `NSStringFromString`, `options`, `isKindOfClass`, etc. |
+| `objcjs-types/nsdata`      | NSData/Buffer conversion utilities                     |
+| `objcjs-types/osversion`   | macOS version detection and comparison                 |
+| `objcjs-types/delegates`   | `createDelegate` and `ProtocolMap` type                |
+| `objcjs-types/<Framework>` | Framework exports (e.g. `objcjs-types/AppKit`)         |
+
 ## ObjC selector naming
 
 Objective-C selectors are mapped using `$` as the separator:

package/dist/AVFAudio/AVAudioApplication.d.ts

@@ -19,11 +19,11 @@ export declare class _AVAudioApplication extends _NSObject {
     /**
      * @brief Set the muted/unmuted state of the application's audio input. When set true, inputs (microphone etc.) of all audio clients relating to this application will have their samples zeroed out. @note - this is per-application input muting and doesn't affect the hardware mute state.
      */
-    setInputMuted$error$(muted: boolean, outError: NobjcObject): boolean;
+    setInputMuted$error$(muted: boolean, outError: NobjcObject | null): boolean;
     /**
      * @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, outError: NobjcObject): boolean;
+    setInputMuteStateChangeHandler$error$(inputMuteHandler: NobjcObject | 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/AVAudioBuffer.d.ts

@@ -1,4 +1,6 @@
 import type { NobjcObject } from "objc-js";
+import type { _NSCopying } from "../Foundation/NSCopying.js";
+import type { _NSMutableCopying } from "../Foundation/NSMutableCopying.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVAudioFormat } from "./AVAudioFormat.js";
 export declare class _AVAudioBuffer extends _NSObject {
@@ -16,3 +18,5 @@ export declare class _AVAudioBuffer extends _NSObject {
      */
     mutableAudioBufferList(): NobjcObject;
 }
+export interface _AVAudioBuffer extends _NSCopying, _NSMutableCopying {
+}

package/dist/AVFAudio/AVAudioChannelLayout.d.ts

@@ -1,17 +1,18 @@
 import type { NobjcObject } from "objc-js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 export declare class _AVAudioChannelLayout extends _NSObject {
     static alloc(): _AVAudioChannelLayout;
     static new(): _AVAudioChannelLayout;
     init(): _AVAudioChannelLayout;
     /** @method layoutWithLayoutTag: @abstract Create from a layout tag. */
-    static layoutWithLayoutTag$(layoutTag: NobjcObject): _AVAudioChannelLayout;
+    static layoutWithLayoutTag$(layoutTag: number): _AVAudioChannelLayout;
     /** @method layoutWithLayout: @abstract Create from an AudioChannelLayout */
     static layoutWithLayout$(layout: NobjcObject): _AVAudioChannelLayout;
     /**
      * @method initWithLayoutTag: @abstract Initialize from a layout tag. @param layoutTag The tag. @discussion Returns nil if the tag is either kAudioChannelLayoutTag_UseChannelDescriptions or kAudioChannelLayoutTag_UseChannelBitmap.
      */
-    initWithLayoutTag$(layoutTag: NobjcObject): _AVAudioChannelLayout | null;
+    initWithLayoutTag$(layoutTag: number): _AVAudioChannelLayout | null;
     /**
      * @method initWithLayout: @abstract Initialize from an AudioChannelLayout. @param layout The AudioChannelLayout. @discussion If the provided layout's tag is kAudioChannelLayoutTag_UseChannelDescriptions, this initializer attempts to convert it to a more specific tag.
      */
@@ -21,9 +22,11 @@ export declare class _AVAudioChannelLayout extends _NSObject {
      */
     isEqual$(object_: NobjcObject): boolean;
     /** @property layoutTag @abstract The layout's tag. */
-    layoutTag(): NobjcObject;
+    layoutTag(): number;
     /** @property layout @abstract The underlying AudioChannelLayout. */
     layout(): NobjcObject;
     /** @property channelCount @abstract The number of channels of audio data. */
     channelCount(): number;
 }
+export interface _AVAudioChannelLayout extends _NSSecureCoding {
+}

package/dist/AVFAudio/AVAudioCompressedBuffer.d.ts

@@ -38,7 +38,7 @@ export declare class _AVAudioCompressedBuffer extends _AVAudioBuffer {
     /**
      * @property packetDescriptions @abstract Access the buffer's array of packet descriptions, if any. @discussion If the format has constant bytes per packet (format.streamDescription->mBytesPerPacket != 0), then this will return nil.
      */
-    packetDescriptions(): NobjcObject;
+    packetDescriptions(): NobjcObject | null;
     /**
      * @property packetDependencies @abstract Access the buffer's array of packet dependencies, if any. @discussion If the format doesn't employ packet dependencies, this will be nil.
      */

package/dist/AVFAudio/AVAudioConverter.d.ts

@@ -26,11 +26,11 @@ export declare class _AVAudioConverter extends _NSObject {
     /**
      * @method convertToBuffer:fromBuffer:error: @abstract Perform a simple conversion. That is, a conversion which does not involve codecs or sample rate conversion. @param inputBuffer The input buffer. @param outputBuffer The output buffer. @param outError An error if the conversion fails. @return YES is returned on success, NO when an error has occurred. @discussion The output buffer's frameCapacity should be at least at large as the inputBuffer's frameLength. If the conversion involves a codec or sample rate conversion, you instead must use convertToBuffer:error:withInputFromBlock:.
      */
-    convertToBuffer$fromBuffer$error$(outputBuffer: _AVAudioPCMBuffer, inputBuffer: _AVAudioPCMBuffer, outError: NobjcObject): boolean;
+    convertToBuffer$fromBuffer$error$(outputBuffer: _AVAudioPCMBuffer, inputBuffer: _AVAudioPCMBuffer, outError: NobjcObject | null): boolean;
     /**
      * @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, inputBlock: number): AVAudioConverterOutputStatus;
+    convertToBuffer$error$withInputFromBlock$(outputBuffer: _AVAudioBuffer, outError: NobjcObject | null, inputBlock: NobjcObject): AVAudioConverterOutputStatus;
     /**
      * @property inputFormat @abstract The format of the input audio stream. (NB. AVAudioFormat includes the channel layout)
      */

package/dist/AVFAudio/AVAudioEngine.d.ts

@@ -61,7 +61,7 @@ export declare class _AVAudioEngine extends _NSObject {
     /**
      * Start the engine. YES for success Calls prepare if it has not already been called since stop. When the engine is rendering to/from an audio device, starts the audio hardware via the AVAudioInputNode and/or AVAudioOutputNode instances in the engine. Audio begins to flow through the engine. Reasons for potential failure to start in this mode include: 1. There is problem in the structure of the graph. Input can't be routed to output or to a recording tap through converter type nodes. 2. An AVAudioSession error. 3. The driver failed to start the hardware. In manual rendering mode, prepares the engine to render when requested by the client. On AVAudioSession supported platforms, this method may cause the audio session to be implicitly activated. It is recommended to configure and activate the app's audio session before starting the engine. For more information, see the `prepare` method above.
      */
-    startAndReturnError$(outError: NobjcObject): boolean;
+    startAndReturnError$(outError: NobjcObject | null): boolean;
     /**
      * Pause the engine. When the engine is rendering to/from an audio device, stops the audio hardware and the flow of audio through the engine. When operating in this mode, it is recommended that the engine be paused or stopped (as applicable) when not in use, to minimize power consumption. Pausing the engine does not deallocate the resources allocated by prepare. Resume the engine by invoking start again.
      */
@@ -85,7 +85,7 @@ export declare class _AVAudioEngine extends _NSObject {
     /**
      * Set the engine to operate in a manual rendering mode with the specified render format and maximum frame count. The manual rendering mode to use. The format of the output PCM audio data from the engine. The maximum number of PCM sample frames the engine will be asked to produce in any single render call. On exit, if the engine cannot switch to the manual rendering mode, a description of the error (see `AVAudioEngineManualRenderingError` for the possible errors). YES for success. Use this method to configure the engine to render in response to requests from the client. The engine must be in a stopped state before calling this method. The render format must be a PCM format and match the format of the buffer to which the engine is asked to render (see `renderOffline:toBuffer:error:`). It is advised to enable manual rendering mode soon after the engine is created, and before accessing any of mainMixerNode, inputNode or outputNode of the engine. Otherwise, accessing or interacting with the engine before enabling manual rendering mode could have the unintended side-effect of configuring the hardware for device-rendering mode. The input data in manual rendering mode can be supplied through the source nodes, e.g. `AVAudioPlayerNode`, `AVAudioInputNode` etc. When switching to manual rendering mode, the engine: 1. Switches the input and output nodes to manual rendering mode. Their input and output formats may change. 2. Removes any taps previously installed on the input and output nodes. 3. Maintains all the engine connections as is. Reasons for potential failure when switching to manual rendering mode include: - Engine is not in a stopped state.
      */
-    enableManualRenderingMode$format$maximumFrameCount$error$(mode: AVAudioEngineManualRenderingMode, pcmFormat: _AVAudioFormat, maximumFrameCount: number, outError: NobjcObject): boolean;
+    enableManualRenderingMode$format$maximumFrameCount$error$(mode: AVAudioEngineManualRenderingMode, pcmFormat: _AVAudioFormat, maximumFrameCount: number, outError: NobjcObject | null): boolean;
     /**
      * Set the engine to render to/from an audio device. When disabling the manual rendering mode, the engine: 1. Stops and resets itself (see `stop` and `reset`). 2. Switches the output/input nodes to render to/from an audio device. Their input and output formats may change. 3. Removes any taps previously installed on the input and output nodes. 4. Maintains all the engine connections as is. Calling this method when the engine is already rendering to/from an audio device has no effect.
      */
@@ -93,25 +93,25 @@ export declare class _AVAudioEngine extends _NSObject {
     /**
      * Render call to the engine operating in the offline manual rendering mode The number of PCM sample frames to be rendered The PCM buffer to which the engine must render the audio On exit, if an error occurs during rendering, a description of the error (see `AVAudioEngineManualRenderingError` for the possible errors) One of the status codes from `AVAudioEngineManualRenderingStatus`. Irrespective of the returned status code, on exit, the output buffer's frameLength will indicate the number of PCM samples rendered by the engine The engine must be in the offline manual rendering mode (`AVAudioEngineManualRenderingModeOffline`) and started before calling this method. The format of the buffer must match the render format set through `enableManualRenderingMode:format:maximumFrameCount:error:`. The buffer capacity must be greater than or equal to the number of samples asked to render. On exit, the buffer's frameLength will indicate the number of PCM samples rendered by the engine. The engine's timeline in manual rendering mode starts at a sample time of zero, and is in terms of the render format's sample rate. Resetting the engine (see `reset`) will reset the timeline back to zero. When rendering in `AVAudioEngineManualRenderingModeRealtime`, this ObjC render method must not be used, an error is returned otherwise. Use the block based render call (`manualRenderingBlock`) in that mode instead.
      */
-    renderOffline$toBuffer$error$(numberOfFrames: number, buffer: _AVAudioPCMBuffer, outError: NobjcObject): AVAudioEngineManualRenderingStatus;
+    renderOffline$toBuffer$error$(numberOfFrames: number, buffer: _AVAudioPCMBuffer, outError: NobjcObject | null): AVAudioEngineManualRenderingStatus;
     /**
      * 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): void;
+    connectMIDI$to$format$block$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: NobjcObject | 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): void;
+    connectMIDI$to$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: NobjcObject | 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): void;
+    connectMIDI$toNodes$format$block$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: NobjcObject | 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): void;
+    connectMIDI$toNodes$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: NobjcObject | 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.
      */
@@ -129,8 +129,8 @@ export declare class _AVAudioEngine extends _NSObject {
      */
     disconnectMIDIOutput$(node: _AVAudioNode): void;
     /** The MusicSequence previously attached to the engine (if any). */
-    musicSequence(): NobjcObject;
-    setMusicSequence$(value: NobjcObject): void;
+    musicSequence(): NobjcObject | null;
+    setMusicSequence$(value: NobjcObject | null): void;
     /**
      * The engine's singleton output node. Audio output is performed via an output node. The engine creates a singleton on demand when this property is first accessed. Connect another node to the input of the output node, or obtain a mixer that is connected there by default, using the "mainMixerNode" property. When the engine is rendering to/from an audio device, the AVAudioSesssion category and/or availability of hardware determine whether an app can perform output. Check the output format of output node (i.e. hardware format) for non-zero sample rate and channel count to see if output is enabled. Trying to perform output through the output node when it is not enabled or available will cause the engine to throw an error (when possible) or an exception. In manual rendering mode, the output format of the output node will determine the render format of the engine. It can be changed through `enableManualRenderingMode:format:maximumFrameCount:error:`.
      */
@@ -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(): number;
+    manualRenderingBlock(): NobjcObject;
     /**
      * 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/AVAudioEnvironmentNode.d.ts

@@ -1,5 +1,6 @@
 import type { _AVAudioEnvironmentDistanceAttenuationParameters } from "./AVAudioEnvironmentDistanceAttenuationParameters.js";
 import type { _AVAudioEnvironmentReverbParameters } from "./AVAudioEnvironmentReverbParameters.js";
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
 import type { _NSArray } from "../Foundation/NSArray.js";
 import type { AVAudio3DAngularOrientation } from "../structs/AVAudio3DAngularOrientation.js";
@@ -53,3 +54,5 @@ export declare class _AVAudioEnvironmentNode extends _AVAudioNode {
     listenerHeadTrackingEnabled(): boolean;
     setListenerHeadTrackingEnabled$(value: boolean): void;
 }
+export interface _AVAudioEnvironmentNode extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioFile.d.ts

@@ -13,19 +13,19 @@ export declare class _AVAudioFile extends _NSObject {
     /**
      * Open a file for reading. the file to open on exit, if an error occurs, a description of the error This opens the file for reading using the standard format (deinterleaved floating point).
      */
-    initForReading$error$(fileURL: _NSURL, outError: NobjcObject): _AVAudioFile | null;
+    initForReading$error$(fileURL: _NSURL, outError: NobjcObject | null): _AVAudioFile | null;
     /**
      * Open a file for reading, using a specified processing format. the file to open the processing format to use when reading from the file whether to use an interleaved processing format on exit, if an error occurs, a description of the error
      */
-    initForReading$commonFormat$interleaved$error$(fileURL: _NSURL, format: AVAudioCommonFormat, interleaved: boolean, outError: NobjcObject): _AVAudioFile | null;
+    initForReading$commonFormat$interleaved$error$(fileURL: _NSURL, format: AVAudioCommonFormat, interleaved: boolean, outError: NobjcObject | null): _AVAudioFile | null;
     /**
      * Open a file for writing. the path at which to create the file the format of the file to create (See `AVAudioRecorder`.) For linear PCM, only interleaved formats are supported for the saved file, non interleaved setting will be ignored and a warning is shown. on exit, if an error occurs, a description of the error The file type to create can be set through the corresponding settings key. If not set, it will be inferred from the file extension. Will overwrite a file at the specified URL if a file exists. This opens the file for writing using the standard format (deinterleaved floating point).
      */
-    initForWriting$settings$error$(fileURL: _NSURL, settings: _NSDictionary, outError: NobjcObject): _AVAudioFile | null;
+    initForWriting$settings$error$(fileURL: _NSURL, settings: _NSDictionary, outError: NobjcObject | null): _AVAudioFile | null;
     /**
      * Open a file for writing. the path at which to create the file the format of the file to create (See `AVAudioRecorder`.) For linear PCM, only interleaved formats are supported for the saved file, non interleaved setting will be ignored and a warning is shown. the processing format to use when writing to the file. whether to use an interleaved processing format on exit, if an error occurs, a description of the error The file type to create can be set through the corresponding settings key. If not set, it will be inferred from the file extension. Will overwrite a file at the specified URL if a file exists.
      */
-    initForWriting$settings$commonFormat$interleaved$error$(fileURL: _NSURL, settings: _NSDictionary, format: AVAudioCommonFormat, interleaved: boolean, outError: NobjcObject): _AVAudioFile | null;
+    initForWriting$settings$commonFormat$interleaved$error$(fileURL: _NSURL, settings: _NSDictionary, format: AVAudioCommonFormat, interleaved: boolean, outError: NobjcObject | null): _AVAudioFile | null;
     /**
      * Close the audio file. The underlying file will be closed if open. - It is normally unnecessary to close a file opened for reading (it will be automatically closed when the object is released) - It is only necessary to close a file opened for writing in order to achieve specific control over when the file's header is updated. Note: Once closed, further file read or write operations will fail with kAudio_FileNotFoundError.
      */
@@ -33,15 +33,15 @@ export declare class _AVAudioFile extends _NSObject {
     /**
      * Read an entire buffer. The buffer into which to read from the file. Its format must match the file's processing format. on exit, if an error occurs, a description of the error YES for success. Reading sequentially from framePosition, attempts to fill the buffer to its capacity. On return, the buffer's length indicates the number of sample frames successfully read.
      */
-    readIntoBuffer$error$(buffer: _AVAudioPCMBuffer, outError: NobjcObject): boolean;
+    readIntoBuffer$error$(buffer: _AVAudioPCMBuffer, outError: NobjcObject | null): boolean;
     /**
      * Read a portion of a buffer. The number of frames to read. The buffer into which to read from the file. Its format must match the file's processing format. on exit, if an error occurs, a description of the error YES for success. Like `readIntoBuffer:error:`, but can be used to read fewer frames than buffer.frameCapacity.
      */
-    readIntoBuffer$frameCount$error$(buffer: _AVAudioPCMBuffer, frames: number, outError: NobjcObject): boolean;
+    readIntoBuffer$frameCount$error$(buffer: _AVAudioPCMBuffer, frames: number, outError: NobjcObject | null): boolean;
     /**
      * Write a buffer. The buffer from which to write to the file. Its format must match the file's processing format. on exit, if an error occurs, a description of the error YES for success. Writes sequentially. The buffer's frameLength signifies how much of the buffer is to be written.
      */
-    writeFromBuffer$error$(buffer: _AVAudioPCMBuffer, outError: NobjcObject): boolean;
+    writeFromBuffer$error$(buffer: _AVAudioPCMBuffer, outError: NobjcObject | null): boolean;
     /** Whether the file is open or not. */
     isOpen(): boolean;
     /** The URL the file is reading or writing. */

package/dist/AVFAudio/AVAudioFormat.d.ts

@@ -2,6 +2,7 @@ import type { NobjcObject } from "objc-js";
 import type { _NSData } from "../Foundation/NSData.js";
 import type { _NSDictionary } from "../Foundation/NSDictionary.js";
 import type { _NSObject } from "../Foundation/NSObject.js";
+import type { _NSSecureCoding } from "../Foundation/NSSecureCoding.js";
 import type { _AVAudioChannelLayout } from "./AVAudioChannelLayout.js";
 import type { AVAudioCommonFormat } from "./AVAudioCommonFormat.js";
 export declare class _AVAudioFormat extends _NSObject {
@@ -82,3 +83,5 @@ export declare class _AVAudioFormat extends _NSObject {
      */
     formatDescription(): NobjcObject;
 }
+export interface _AVAudioFormat extends _NSSecureCoding {
+}

package/dist/AVFAudio/AVAudioIONode.d.ts

@@ -7,7 +7,7 @@ export declare class _AVAudioIONode extends _AVAudioNode {
     /**
      * @method setVoiceProcessingEnabled:error: @abstract Enable or disable voice processing on the IO node. @param enabled Whether voice processing is to be enabled. @param outError On exit, if the IO node cannot enable or diable voice processing, a description of the error @return YES for success @discussion If enabled, the input node does signal processing on the incoming audio (taking out any of the audio that is played from the device at a given time from the incoming audio). Disabling this mode on either of the IO nodes automatically disabled it on the other IO node. Voice processing requires both input and output nodes to be in the voice processing mode. Enabling this mode on either of the IO nodes automatically enables it on the other IO node. Voice processing is only supported when the engine is rendering to the audio device and not in the manual rendering mode. Voice processing can only be be enabled or disabled when the engine is in a stopped state. The output format of the input node and the input format of the output node have to be the same and they can only be changed when the engine is in a stopped state.
      */
-    setVoiceProcessingEnabled$error$(enabled: boolean, outError: NobjcObject): boolean;
+    setVoiceProcessingEnabled$error$(enabled: boolean, outError: NobjcObject | null): boolean;
     /**
      * @property presentationLatency @abstract The presentation or hardware latency, applicable when the engine is rendering to/from an audio device. @discussion This corresponds to kAudioDevicePropertyLatency and kAudioStreamPropertyLatency. See <CoreAudio/AudioHardwareBase.h>.
      */
@@ -15,7 +15,7 @@ export declare class _AVAudioIONode extends _AVAudioNode {
     /**
      * @property audioUnit @abstract The node's underlying AudioUnit, if any. @discussion This is only necessary for certain advanced usages.
      */
-    audioUnit(): NobjcObject;
+    audioUnit(): NobjcObject | null;
     /**
      * @property voiceProcessingEnabled @abstract Indicates whether voice processing is enabled.
      */

package/dist/AVFAudio/AVAudioInputNode.d.ts

@@ -1,6 +1,7 @@
 import type { NobjcObject } from "objc-js";
 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";
 export declare class _AVAudioInputNode extends _AVAudioIONode {
     static alloc(): _AVAudioInputNode;
@@ -9,11 +10,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: number): boolean;
+    setManualRenderingInputPCMFormat$inputBlock$(format: _AVAudioFormat, block: 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): boolean;
+    setMutedSpeechActivityEventListener$(listenerBlock: NobjcObject | 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.
      */
@@ -35,3 +36,5 @@ export declare class _AVAudioInputNode extends _AVAudioIONode {
     voiceProcessingOtherAudioDuckingConfiguration(): AVAudioVoiceProcessingOtherAudioDuckingConfiguration;
     setVoiceProcessingOtherAudioDuckingConfiguration$(value: AVAudioVoiceProcessingOtherAudioDuckingConfiguration): void;
 }
+export interface _AVAudioInputNode extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioMixerNode.d.ts

@@ -1,3 +1,4 @@
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
 export declare class _AVAudioMixerNode extends _AVAudioNode {
     static alloc(): _AVAudioMixerNode;
@@ -13,3 +14,5 @@ export declare class _AVAudioMixerNode extends _AVAudioNode {
      */
     nextAvailableInputBus(): number;
 }
+export interface _AVAudioMixerNode extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioMixingDestination.d.ts

@@ -1,5 +1,6 @@
 import type { _NSObject } from "../Foundation/NSObject.js";
 import type { _AVAudioConnectionPoint } from "./AVAudioConnectionPoint.js";
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 export declare class _AVAudioMixingDestination extends _NSObject {
     static alloc(): _AVAudioMixingDestination;
     static new(): _AVAudioMixingDestination;
@@ -9,3 +10,5 @@ export declare class _AVAudioMixingDestination extends _NSObject {
      */
     connectionPoint(): _AVAudioConnectionPoint;
 }
+export interface _AVAudioMixingDestination extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioNode.d.ts

@@ -1,3 +1,4 @@
+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";
@@ -21,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: number): void;
+    installTapOnBus$bufferSize$format$block$(bus: number, bufferSize: number, format: _AVAudioFormat | null, tapBlock: NobjcObject): 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): _AVAudioPCMBuffer | null;
+    initWithPCMFormat$bufferListNoCopy$deallocator$(format: _AVAudioFormat, bufferList: NobjcObject, deallocator: NobjcObject | null): _AVAudioPCMBuffer | null;
     /**
      * @property frameCapacity @abstract The buffer's capacity, in audio sample frames.
      */
@@ -29,13 +29,13 @@ export declare class _AVAudioPCMBuffer extends _AVAudioBuffer {
     /**
      * @property floatChannelData @abstract Access the buffer's float audio samples. @discussion floatChannelData returns pointers to the buffer's audio samples if the buffer's format is 32-bit float, or nil if it is another format. The returned pointer is to format.channelCount pointers to float. Each of these pointers is to "frameLength" valid samples, which are spaced by "stride" samples. If format.interleaved is false (as with the standard deinterleaved float format), then the pointers will be to separate chunks of memory. "stride" is 1. If format.interleaved is true, then the pointers will refer into the same chunk of interleaved samples, each offset by 1 frame. "stride" is the number of interleaved channels.
      */
-    floatChannelData(): NobjcObject;
+    floatChannelData(): NobjcObject | null;
     /**
      * @property int16ChannelData @abstract Access the buffer's int16_t audio samples. @discussion int16ChannelData returns the buffer's audio samples if the buffer's format has 2-byte integer samples, or nil if it is another format. See the discussion of floatChannelData.
      */
-    int16ChannelData(): NobjcObject;
+    int16ChannelData(): NobjcObject | null;
     /**
      * @property int32ChannelData @abstract Access the buffer's int32_t audio samples. @discussion int32ChannelData returns the buffer's audio samples if the buffer's format has 4-byte integer samples, or nil if it is another format. See the discussion of floatChannelData.
      */
-    int32ChannelData(): NobjcObject;
+    int32ChannelData(): NobjcObject | null;
 }

package/dist/AVFAudio/AVAudioPlayer.d.ts

@@ -12,13 +12,13 @@ export declare class _AVAudioPlayer extends _NSObject {
     static new(): _AVAudioPlayer;
     init(): _AVAudioPlayer;
     /** all data must be in the form of an audio file understood by CoreAudio */
-    initWithContentsOfURL$error$(url: _NSURL, outError: NobjcObject): _AVAudioPlayer | null;
-    initWithData$error$(data: _NSData, outError: NobjcObject): _AVAudioPlayer | null;
+    initWithContentsOfURL$error$(url: _NSURL, outError: NobjcObject | null): _AVAudioPlayer | null;
+    initWithData$error$(data: _NSData, outError: NobjcObject | null): _AVAudioPlayer | null;
     /**
      * The file type hint is a constant defined in AVMediaFormat.h whose value is a UTI for a file format. e.g. AVFileTypeAIFF. Sometimes the type of a file cannot be determined from the data, or it is actually corrupt. The file type hint tells the parser what kind of data to look for so that files which are not self identifying or possibly even corrupt can be successfully parsed.
      */
-    initWithContentsOfURL$fileTypeHint$error$(url: _NSURL, utiString: _NSString | null, outError: NobjcObject): _AVAudioPlayer | null;
-    initWithData$fileTypeHint$error$(data: _NSData, utiString: _NSString | null, outError: NobjcObject): _AVAudioPlayer | null;
+    initWithContentsOfURL$fileTypeHint$error$(url: _NSURL, utiString: _NSString | null, outError: NobjcObject | null): _AVAudioPlayer | null;
+    initWithData$fileTypeHint$error$(data: _NSData, utiString: _NSString | null, outError: NobjcObject | null): _AVAudioPlayer | null;
     /**
      * Transport control Methods that return BOOL return YES on success and NO on failure. Get ready to play the sound. This happens automatically on play.
      */

package/dist/AVFAudio/AVAudioPlayerNode.d.ts

@@ -1,4 +1,6 @@
+import type { NobjcObject } from "objc-js";
 import type { _AVAudioFile } from "./AVAudioFile.js";
+import type { _AVAudioMixing } from "./AVAudioMixing.js";
 import type { _AVAudioNode } from "./AVAudioNode.js";
 import type { _AVAudioPCMBuffer } from "./AVAudioPCMBuffer.js";
 import type { _AVAudioTime } from "./AVAudioTime.js";
@@ -11,35 +13,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: number | null): void;
+    scheduleBuffer$completionHandler$(buffer: _AVAudioPCMBuffer, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleBuffer$completionCallbackType$completionHandler$(buffer: _AVAudioPCMBuffer, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleBuffer$atTime$options$completionHandler$(buffer: _AVAudioPCMBuffer, when: _AVAudioTime | null, options: AVAudioPlayerNodeBufferOptions, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleBuffer$atTime$options$completionCallbackType$completionHandler$(buffer: _AVAudioPCMBuffer, when: _AVAudioTime | null, options: AVAudioPlayerNodeBufferOptions, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleFile$atTime$completionHandler$(file: _AVAudioFile, when: _AVAudioTime | null, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleFile$atTime$completionCallbackType$completionHandler$(file: _AVAudioFile, when: _AVAudioTime | null, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleSegment$startingFrame$frameCount$atTime$completionHandler$(file: _AVAudioFile, startFrame: number, numberFrames: number, when: _AVAudioTime | null, completionHandler: NobjcObject | 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: number | null): void;
+    scheduleSegment$startingFrame$frameCount$atTime$completionCallbackType$completionHandler$(file: _AVAudioFile, startFrame: number, numberFrames: number, when: _AVAudioTime | null, callbackType: AVAudioPlayerNodeCompletionCallbackType, completionHandler: NobjcObject | 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.
      */
@@ -71,3 +73,5 @@ export declare class _AVAudioPlayerNode extends _AVAudioNode {
     /** @property playing @abstract Indicates whether or not the player is playing. */
     playing(): boolean;
 }
+export interface _AVAudioPlayerNode extends _AVAudioMixing {
+}

package/dist/AVFAudio/AVAudioRecorder.d.ts

@@ -12,11 +12,11 @@ export declare class _AVAudioRecorder extends _NSObject {
     /**
      * @method initWithURL:settings:error: @abstract Init the AudioRecorder with a specified url and settings. @discussion The file type to create can be set through the corresponding settings key. If not set, it will be inferred from the file extension. Will overwrite a file at the specified url if a file exists.
      */
-    initWithURL$settings$error$(url: _NSURL, settings: _NSDictionary, outError: NobjcObject): _AVAudioRecorder | null;
+    initWithURL$settings$error$(url: _NSURL, settings: _NSDictionary, outError: NobjcObject | null): _AVAudioRecorder | null;
     /**
      * @method initWithURL:format:error: @abstract Init the AudioRecorder with a specified url and format. @discussion The file type to create can be set through the corresponding settings key. If not set, it will be inferred from the file extension. Will overwrite a file at the specified url if a file exists.
      */
-    initWithURL$format$error$(url: _NSURL, format: _AVAudioFormat, outError: NobjcObject): _AVAudioRecorder | null;
+    initWithURL$format$error$(url: _NSURL, format: _AVAudioFormat, outError: NobjcObject | null): _AVAudioRecorder | null;
     /**
      * @method prepareToRecord @abstract Creates the output file and gets ready to record. @discussion This method is called automatically on record. Returns YES on success and NO on failure.
      */

package/dist/AVFAudio/AVAudioRoutingArbiter.d.ts

@@ -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): void;
+    beginArbitrationWithCategory$completionHandler$(category: AVAudioRoutingArbitrationCategory, handler: NobjcObject | 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.
      */