import type { NobjcObject } from "objc-js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _NSSet } from "../Foundation/NSSet.js";
import type { _AVAudioConnectionPoint } from "./AVAudioConnectionPoint.js";
import type { _AVAudioFormat } from "./AVAudioFormat.js";
import type { _AVAudioInputNode } from "./AVAudioInputNode.js";
import type { _AVAudioMixerNode } from "./AVAudioMixerNode.js";
import type { _AVAudioNode } from "./AVAudioNode.js";
import type { _AVAudioOutputNode } from "./AVAudioOutputNode.js";
import type { _AVAudioPCMBuffer } from "./AVAudioPCMBuffer.js";
import type { AVAudioEngineManualRenderingMode } from "./AVAudioEngineManualRenderingMode.js";
import type { AVAudioEngineManualRenderingStatus } from "./AVAudioEngineManualRenderingStatus.js";
export declare class _AVAudioEngine extends _NSObject {
    static alloc(): _AVAudioEngine;
    static new(): _AVAudioEngine;
    /**
     * Initialize a new engine. On creation, the engine is by default connected to an audio device and automatically renders in realtime. It can be configured to operate in manual rendering mode through `enableManualRenderingMode:format:maximumFrameCount:error:`.
     */
    init(): _AVAudioEngine;
    /**
     * Take ownership of a new node. The node to be attached to the engine. To support the instantiation of arbitrary AVAudioNode subclasses, instances are created externally to the engine, but are not usable until they are attached to the engine via this method. Thus the idiom, without ARC, is: ``` // when building engine: AVAudioNode *_player; // member of controller class (for example) ... _player = [[AVAudioPlayerNode alloc] init]; [engine attachNode: _player]; ... // when destroying engine (without ARC) [_player release]; ```
     */
    attachNode$(node: _AVAudioNode): void;
    /**
     * Detach a node previously attached to the engine. If necessary, the engine will safely disconnect the node before detaching it.
     */
    detachNode$(node: _AVAudioNode): void;
    /**
     * Establish a connection between two nodes. The source node The destination node The output bus on the source node The input bus on 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 destination node's input bus is set to match that of the source node's output bus. Nodes have input and output buses (AVAudioNodeBus). Use this method to establish one-to-one connections betweeen nodes. Connections made using this method are always one-to-one, never one-to-many or many-to-one. Note that any pre-existing connection(s) involving the source's output bus or the destination's input bus will be broken.
     */
    connect$to$fromBus$toBus$format$(node1: _AVAudioNode, node2: _AVAudioNode, bus1: number, bus2: number, format: _AVAudioFormat | null): void;
    /**
     * Establish a connection between two nodes This calls connect:to:fromBus:toBus:format: using bus 0 on the source node, and bus 0 on the destination node, except in the case of a destination which is a mixer, in which case the destination is the mixer's nextAvailableInputBus.
     */
    connect$to$format$(node1: _AVAudioNode, node2: _AVAudioNode, format: _AVAudioFormat | null): void;
    /**
     * Establish connections between a source node and multiple destination nodes. The source node An array of AVAudioConnectionPoint objects specifying destination nodes and busses The output bus on source 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 destination nodes' input bus is set to match that of the source node's output bus Use this method to establish connections from a source node to multiple destination nodes. 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. To incrementally add a new connection to a source node, use this method with an array of AVAudioConnectionPoint objects comprising of pre-existing connections (obtained from `outputConnectionPointsForNode:outputBus:`) and the new connection. Note that any pre-existing connection involving the destination's input bus will be broken. And, any pre-existing connection on source node which is not a part of the specified destination connection array will also be broken. Also note that when the output of a node is split into multiple paths, all the paths must render at the same rate until they reach a common mixer. In other words, starting from the split node until the common mixer node where all split paths terminate, you cannot have: - any AVAudioUnitTimeEffect - any sample rate conversion
     */
    connect$toConnectionPoints$fromBus$format$(sourceNode: _AVAudioNode, destNodes: _NSArray, sourceBus: number, format: _AVAudioFormat | null): void;
    /**
     * Remove a connection between two nodes. The node whose input is to be disconnected The destination's input bus to disconnect
     */
    disconnectNodeInput$bus$(node: _AVAudioNode, bus: number): void;
    /**
     * Remove a connection between two nodes. The node whose inputs are to be disconnected Connections are broken on each of the node's input busses.
     */
    disconnectNodeInput$(node: _AVAudioNode): void;
    /**
     * Remove a connection between two nodes. The node whose output is to be disconnected The source's output bus to disconnect
     */
    disconnectNodeOutput$bus$(node: _AVAudioNode, bus: number): void;
    /**
     * Remove a connection between two nodes. The node whose outputs are to be disconnected Connections are broken on each of the node's output busses.
     */
    disconnectNodeOutput$(node: _AVAudioNode): void;
    /**
     * Prepare the engine for starting. This method preallocates many of the resources the engine requires in order to start. Use it to responsively start audio input or output. On AVAudioSession supported platforms, this method may cause the audio session to be implicitly activated. Activating the audio session (implicitly or explicitly) may cause other audio sessions to be interrupted or ducked depending on the session's configuration. It is recommended to configure and activate the app's audio session before preparing the engine. See https://developer.apple.com/library/archive/documentation/Audio/Conceptual/AudioSessionProgrammingGuide/Introduction/Introduction.html for details.
     */
    prepare(): void;
    /**
     * 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 | 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.
     */
    pause(): void;
    /**
     * reset Reset all of the nodes in the engine. This will reset all of the nodes in the engine. This is useful, for example, for silencing reverb and delay tails. In manual rendering mode, the render timeline is reset to a sample time of zero.
     */
    reset(): void;
    /**
     * When the engine is rendering to/from an audio device, stops the audio hardware and 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. Stopping the engine releases the resources allocated by prepare.
     */
    stop(): void;
    /**
     * Get connection information on a node's input bus. The node whose input connection is being queried. The node's input bus on which the connection is being queried. An AVAudioConnectionPoint object with connection information on the node's specified input bus. Connections are always one-to-one or one-to-many, never many-to-one. Returns nil if there is no connection on the node's specified input bus.
     */
    inputConnectionPointForNode$inputBus$(node: _AVAudioNode, bus: number): _AVAudioConnectionPoint | null;
    /**
     * Get connection information on a node's output bus. The node whose output connections are being queried. The node's output bus on which connections are being queried. An array of AVAudioConnectionPoint objects with connection information on the node's specified output bus. Connections are always one-to-one or one-to-many, never many-to-one. Returns an empty array if there are no connections on the node's specified output bus.
     */
    outputConnectionPointsForNode$outputBus$(node: _AVAudioNode, bus: number): _NSArray;
    /**
     * 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 | 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.
     */
    disableManualRenderingMode(): void;
    /**
     * 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 | 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: ((arg0: number, arg1: number, arg2: number, arg3: NobjcObject) => number) | null): void;
    /**
     * Establish a MIDI only connection between two nodes. The source node. The destination node. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. This block is called from the source node's `AUMIDIOutputEventListBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. Use this method to establish a MIDI only connection between a source node and a destination node that has MIDI input capability. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. Note that any pre-existing MIDI connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventListBlock` will be overwritten when making the MIDI connection.
     */
    connectMIDI$to$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: NobjcObject) => number) | null): void;
    /**
     * Establish a MIDI only connection between a source node and multiple destination nodes. The source node. An array of AVAudioNodes specifying destination nodes. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. If non-nil, this block is called from the source node's `AUMIDIOutputEventBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. May be nil. Use this method to establish a MIDI only connection between a source node and multiple destination nodes. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. MIDI connections made using this method are either one-to-one (when a single destination connection is specified) or one-to-many (when multiple connections are specified), but never many-to-one. Note that any pre-existing connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventBlock` will be overwritten when making the MIDI connection.
     * @deprecated connectMIDI:toNodes:format:eventListBlock:
     */
    connectMIDI$toNodes$format$block$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: number, arg3: NobjcObject) => number) | null): void;
    /**
     * Establish a MIDI only connection between a source node and multiple destination nodes. The source node. An array of AVAudioNodes specifying destination nodes. If non-nil, the format of the source node's output bus is set to this format. In all cases, the format of the source nodes' output bus has to match with the destination nodes' output bus format. Although the output bus of the source is not in use, the format needs to be set in order to be able to use the sample rate for MIDI event timing calculations. This block is called from the source node's `AUMIDIOutputEventListBlock` on the realtime thread. The host can tap the MIDI data of the source node through this block. Use this method to establish a MIDI only connection between a source node and multiple destination nodes. The source node can only be a AVAudioUnit node of type `kAudioUnitType_MIDIProcessor`. The destination node types can be `kAudioUnitType_MusicDevice`, `kAudioUnitType_MusicEffect` or `kAudioUnitType_MIDIProcessor`. MIDI connections made using this method are either one-to-one (when a single destination connection is specified) or one-to-many (when multiple connections are specified), but never many-to-one. Note that any pre-existing connection involving the destination will be broken. Any client installed block on the source node's audio unit `AUMIDIOutputEventListBlock` will be overwritten when making the MIDI connection.
     */
    connectMIDI$toNodes$format$eventListBlock$(sourceNode: _AVAudioNode, destinationNodes: _NSArray, format: _AVAudioFormat | null, tapBlock: ((arg0: number, arg1: number, arg2: NobjcObject) => number) | null): void;
    /**
     * Remove a MIDI connection between two nodes. The node whose MIDI output is to be disconnected. The node whose MIDI input is to be disconnected. If a tap block is installed on the source node, it will be removed when the last connection from the source node is removed.
     */
    disconnectMIDI$from$(sourceNode: _AVAudioNode, destinationNode: _AVAudioNode): void;
    /**
     * Remove a MIDI connection between one source node and multiple destination nodes. The node whose MIDI output is to be disconnected. An array of AVAudioNodes specifying nodes 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.
     */
    disconnectMIDI$fromNodes$(sourceNode: _AVAudioNode, destinationNodes: _NSArray): void;
    /**
     * Disconnects all input MIDI connections of this node. The node whose MIDI input is to be disconnected.
     */
    disconnectMIDIInput$(node: _AVAudioNode): void;
    /**
     * Disconnects all output MIDI connections of this node. The node whose MIDI outputs are to be disconnected.
     */
    disconnectMIDIOutput$(node: _AVAudioNode): void;
    /** The MusicSequence previously attached to the engine (if any). */
    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:`.
     */
    outputNode(): _AVAudioOutputNode;
    /**
     * The engine's singleton input node. Audio input is performed via an input node. The engine creates a singleton on demand when this property is first accessed. To receive input, connect another node from the output of the input node, or create a recording tap on it. When the engine is rendering to/from an audio device, the AVAudioSesssion category and/or availability of hardware determine whether an app can perform input. Check for the input node's input format (i.e. hardware format) for non-zero sample rate and channel count to see if input is enabled. Trying to perform input through the input node when it is not enabled or available will cause the engine to throw an error (when possible) or an exception. Note that if the engine has at any point previously had its inputNode enabled and permission to record was granted, then any time the engine is running, the mic-in-use indicator will appear. For applications which may need to dynamically switch between output-only and input-output modes, it may be advantageous to use two engine instances. In manual rendering mode, the input node can be used to synchronously supply data to the engine while it is rendering (see `AVAudioInputNode(setManualRenderingInputPCMFormat:inputBlock:)`.
     */
    inputNode(): _AVAudioInputNode;
    /**
     * The engine's optional singleton main mixer node. The engine will construct a singleton main mixer and connect it to the outputNode on demand, when this property is first accessed. You can then connect additional nodes to the mixer. If the client has never explicitly set the connection format between the mainMixerNode and the outputNode, the engine will always set/update the format to track the format of the outputNode on (re)start, even after an AVAudioEngineConfigurationChangeNotification. Otherwise, it's the client's responsibility to set/update this connection format after an AVAudioEngineConfigurationChangeNotification. By default, the mixer's output format (sample rate and channel count) will track the format of the output node. You may however make the connection explicitly with a different format.
     */
    mainMixerNode(): _AVAudioMixerNode;
    /** The engine's running state. */
    running(): boolean;
    /**
     * When auto shutdown is enabled, the engine can start and stop the audio hardware dynamically, to conserve power. This is the enforced behavior on watchOS and can be optionally enabled on other platforms. To conserve power, it is advised that the client pause/stop the engine when not in use. But when auto shutdown is enabled, the engine will stop the audio hardware if it was running idle for a certain duration, and restart it later when required. Note that, because this operation is dynamic, it may affect the start times of the source nodes (e.g. `AVAudioPlayerNode`), if the engine has to resume from its shutdown state. On watchOS, auto shutdown is always enabled. On other platforms, it is disabled by default, but the client can enable it if needed. This property is applicable only when the engine is rendering to/from an audio device. If the value is changed when the engine is in manual rendering mode, it will take effect whenever the engine is switched to render to/from the audio device.
     */
    autoShutdownEnabled(): boolean;
    setAutoShutdownEnabled$(value: boolean): void;
    /** Set of all nodes attached to the engine. */
    attachedNodes(): _NSSet;
    /**
     * 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(): (arg0: number, arg1: NobjcObject, arg2: NobjcObject) => AVAudioEngineManualRenderingStatus;
    /**
     * Whether or not the engine is operating in manual rendering mode, i.e. not connected to an audio device and rendering in response to the requests from the client
     */
    isInManualRenderingMode(): boolean;
    /**
     * The manual rendering mode configured on the engine This property is meaningful only when the engine is operating in manual rendering mode, i.e. when `isInManualRenderingMode` returns true.
     */
    manualRenderingMode(): AVAudioEngineManualRenderingMode;
    /**
     * The render format of the engine in manual rendering mode. Querying this property when the engine is not in manual rendering mode will return an invalid format, with zero sample rate and channel count.
     */
    manualRenderingFormat(): _AVAudioFormat;
    /**
     * The maximum number of PCM sample frames the engine can produce in any single render call in the manual rendering mode. Querying this property when the engine is not in manual rendering mode will return zero.
     */
    manualRenderingMaximumFrameCount(): number;
    /**
     * Indicates where the engine is on its render timeline in manual rendering mode. The 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.
     */
    manualRenderingSampleTime(): number;
}
