@rnbo/js 0.1.0 → 1.0.0

package/dist/rnbo.webaudio.d.ts

@@ -0,0 +1,1373 @@
+/**
+ * The \@rnbo/js package is the main package for running RNBO Patchers within the Browser.
+ * Using the main entry point {@link createDevice}, RNBO Devices can be created from RNBO Patchers
+ * and integrated into the WebAudio graph of your application.
+ * @packageDocumentation
+ */
+
+/* Excluded from this release type: AsyncEngine */
+
+/* Excluded from this release type: BangParameter */
+
+declare const BangParameter_base: ObjectConstructor & (new (...args: any[]) => CommonParameterMixin);
+
+/* Excluded from this release type: BangValue */
+
+/**
+ * RNBO BaseDevice class.
+ * @public
+ * */
+export declare abstract class BaseDevice {
+    protected _hasPatcher: boolean;
+    protected _sourceType: IPatcherSrc["type"];
+    /* Excluded from this release type: _timeConverter */
+    /* Excluded from this release type: _parameterInterface */
+    /* Excluded from this release type: _engine */
+    protected readonly _context: AudioContext;
+    protected _node?: AudioNode;
+    protected _valid: boolean;
+    protected readonly _type: DeviceType;
+    /**
+     * The {@link EventSubject} for {@link MIDIEvent | MIDIEvents} going out of the RNBO Device
+     *
+     * @example
+     * ```ts
+     * device.midiEvent.subscribe((e: MIDIEvent) => {
+     *   // Handle the MIDIEvent
+     * });
+     * ```
+     * @eventProperty
+     */
+    readonly midiEvent: EventSubject<MIDIEvent>;
+    /**
+     * The {@link EventSubject} for {@link MessageEvent | MessageEvents} going out of the RNBO Device
+     *
+     * @example
+     * ```ts
+     * device.messageEvent.subscribe((e: MessageEvent) => {
+     *   // handle the message event
+     * });
+     * ```
+     * @eventProperty
+     */
+    readonly messageEvent: EventSubject<MessageEvent_2>;
+    /**
+     * The {@link EventSubject} for {@link Parameter} changes of the RNBO Device
+     *
+     * @example
+     * ```ts
+     * device.parameterChangeEvent.subscribe((param: Parameter) => {
+     *   // Code to execute when the parameter assigned to param has changed
+     * });
+     * ```
+     * @eventProperty
+     */
+    readonly parameterChangeEvent: EventSubject<Parameter>;
+    /**
+     * The {@link EventSubject} for invalidation of a RNBO Device. This event is triggered when a call to
+     * {@link createDevice } is called with this device passed as its second argument.
+     *
+     * @example
+     * ```ts
+     * device.invalidateEvent.subscribe(() => {
+     *   // Handle the invalidation
+     * });
+     * ```
+     * @eventProperty
+     */
+    readonly invalidateEvent: EventSubject<void>;
+    /**
+     * The {@link EventSubject} notification when a Preset-relevant value (e.g. parameter) is changed
+     *
+     * @example
+     * ```ts
+     * device.presetTouchedEvent.subscribe(() => {
+     *   // Code to execute when a preset-relevant value has been changed
+     * });
+     * ```
+     * @eventProperty
+     */
+    readonly presetTouchedEvent: EventSubject<void>;
+    /* Excluded from this release type: __constructor */
+    protected _ensureNoPatcher(): void;
+    /* Excluded from this release type: _onEngineEvent */
+    protected _onParameterChangeEvent: (param: Parameter) => void;
+    protected _prepareToProcess(sampleRate: number, samplesPerBlock: number, force: boolean): void;
+    protected _ensureIsValid(): void;
+    protected _extractPatcherCode(src: IPatcherSrc): string;
+    /**
+     * The {@link https://developer.mozilla.org/en-US/docs/Web/API/AudioContext | AudioContext} used for creating the Device. For more information, visit the guide on {@link https://rnbo.cycling74.com/learn/working-with-web-audio-contexts | Working with Web Audio Contexts}
+     */
+    get context(): AudioContext;
+    /**
+     * Property indicating whether the device is valid. A Device will be invalidated when passed to {@link createDevice} as the second argument.
+     */
+    get isValid(): boolean;
+    /**
+     * Property indicating whether the device is invalid. A Device will be invalidated when passed to {@link createDevice} as the second argument.
+     */
+    get isInvalid(): boolean;
+    /**
+     *  Number of input channels supported by the Device and available on its {@link BaseDevice.node}.
+     */
+    get numInputChannels(): number;
+    /**
+     *  Number of output channels supported by the Device and available on its {@link BaseDevice.node}.
+     */
+    get numOutputChannels(): number;
+    /**
+     * Number of MIDI Input ports on the device. If no MIDI Input is enabled the number is zero
+     */
+    get numMIDIInputPorts(): number;
+    /**
+     * Number of MIDI Output ports on the device. If no MIDI Output is present the number is zero
+     */
+    get numMIDIOutputPorts(): number;
+    /**
+     * Parameter count describing the amount of parameters the device has.
+     * Refer to {@link BaseDevice.parameters} on how to access the parameters.
+     */
+    get numParameters(): number;
+    /**
+     * Access the Device parameters as an array. The length of the array equals {@link BaseDevice.numParameters}
+     */
+    get parameters(): Parameter[];
+    get messages(): MessageInfo[];
+    /**
+     * Helper property to get the Device parameters as a Map sorted by their unique id.
+     */
+    get parametersById(): Map<string, Parameter>;
+    /**
+     * Get or Set how the Device should emit {@link BaseDevice.parameterChangeEvent | ParameterChangeEvents}.
+     * See {@link ParameterNotificationSetting} for the available options and details.
+     */
+    get parameterNotificationSetting(): ParameterNotificationSetting;
+    set parameterNotificationSetting(level: ParameterNotificationSetting);
+    get sourceType(): IPatcherSrc["type"];
+    /**
+     * The {@link DeviceType} of the Device. An invalid Device will return {@link DeviceType.Invalid}.
+     */
+    get type(): DeviceType;
+    /**
+     * Retrieve a list of ids for data buffer sources within the patch. These ids can be used to set and retrieve DataBuffers
+     * from a {@link Device} using {@link BaseDevice.(setDataBuffer:1)}
+     *
+     * @deprecated use dataBufferDescriptions instead
+     */
+    get dataBufferIds(): ExternalDataId[];
+    /**
+     * Retrieve a list of descriptions for data buffer sources within the patch.
+     * These contain not only the IDs that can be used to set and retrieve DataBuffers,
+     * but also information about the files the patcher requests to be loaded and the
+     * type of the files (currently only 32 bit audio buffers supported)
+     *
+     * from a {@link Device} using {@link BaseDevice.(setDataBuffer:1)}
+     */
+    get dataBufferDescriptions(): ExternalDataInfo[];
+    /**
+     * Sets the contents of the DataBuffer referenced by the given id to the content of the given AudioBuffer.
+     * Note that a RNBO Device copies the buffer content in order to keep the original buffer fully intact.
+     *
+     * @param id - The id of the DataBuffer to set
+     * @param data - The AudioBuffer to use
+     */
+    setDataBuffer(id: ExternalDataId, data: AudioBuffer): Promise<void>;
+    /**
+     * Sets the contents of the DataBuffer referenced by the given id to the content of the given ArrayBuffer.
+     * The RNBO Device will interpret the data as an Float32Array.
+     * Note that a RNBO Device copies the buffer content in order to keep the original buffer fully intact
+     * and considers the data to be given in an interleaved format while considering the provided channel count
+     * and sample rate.
+     *
+     * @param id - The id of the DataBuffer to set
+     * @param data - The ArrayBuffer to use
+     */
+    setDataBuffer(id: ExternalDataId, data: ArrayBuffer, channelCount: number, sampleRate: number): Promise<void>;
+    /**
+     * Sets the contents of the DataBuffer referenced by the given id to the content of the ArrayBuffer of the provided Float32Array.
+     * Note that a RNBO Device copies the buffer content in order to keep the original buffer fully intact
+     * and considers the data to be given in an interleaved format while considering the provided channel count
+     * and sample rate.
+     *
+     * @param id - The id of the DataBuffer to set
+     * @param data - The Float32Array to use
+     */
+    setDataBuffer(id: ExternalDataId, data: Float32Array, channelCount: number, sampleRate: number): Promise<void>;
+    /**
+     * Releases (resets) the contents of a DataBuffer within the {@link Device} and
+     * returns its contents as a {@link DataBuffer}
+     * @param id - The id of the DataBuffer to release
+     */
+    releaseDataBuffer(id: ExternalDataId): Promise<DataBuffer>;
+    /**
+     * Fetch data from a url and decode it into an AudioBuffer
+     * @param url - The URL to load the data from
+     * @param context - The AudioContext to use
+     */
+    static fetchAudioData(url: string, context: AudioContext): Promise<AudioBuffer>;
+    /**
+     * Determines if buffer info has a remote URL part. For this to be true,
+     * it must either have a "url" key, or else the "file" key must point to
+     * a url with an http or https scheme.
+     * @param info - The buffer info to test
+     */
+    static bufferDescriptionHasRemoteURL(info: ExternalDataInfo): boolean;
+    /**
+     * Load dependencies for data references. For example, if the
+     * patch contained something like [buffer~ anton \@url http://fileplace.org/anton.aif],
+     * retrieve the data at that URL and load it into the appropriate data buffer.
+     *
+     * @example
+     * ```js
+     * // Get dependencies from the device. Note that file dependencies
+     * // stored in the device may not have the correct path.
+     * let bufferDescriptions = device.dataBufferDescriptions;
+     *
+     * // (optional) Filter out file dependencies
+     * bufferDescriptions = bufferDescriptions.filter(BaseDevice.bufferDescriptionHasRemoteURL)
+     *
+     * // load them
+     * device.loadDataBufferDependencies(bufferDescriptions);
+     * ```
+     *
+     * @example
+     * ```js
+     * // Load the exported dependencies.json file
+     * let dependencies = await fetch("dependencies.json");
+     * dependencies = await dependencies.json();
+     *
+     * // Load the dependencies into the device
+     * device.loadDataBufferDependencies(dependencies)
+     * ```
+     *
+     * @param dependencies - an array of {@link ExternalDataInfo} containing buffer ids and resource locations
+     */
+    loadDataBufferDependencies(dependencies: ExternalDataInfo[]): Promise<DependencyLoadDescription[]>;
+    /**
+     * Schedule Events on the device. Refer to Event for possible events.
+     *
+     * @param evt - The event to schedule
+     */
+    scheduleEvent(evt: Event_2): void;
+    /* Excluded from this release type: destroy */
+    /**
+     * Access the AudioNode of the device. Use this to integrate the Device into your WebAudio graph
+     * @example
+     * ```js
+     * const context = new AudioContext();
+     * device.node.connect(context.destination);
+     * ```
+     */
+    abstract get node(): AudioNode;
+    /* Excluded from this release type: setPatcher */
+    /**
+     * Get a {@link IPreset} from the enclosed RNBO patcher, based on its current state.
+     * @public
+     */
+    getPreset(): Promise<IPreset>;
+    /**
+     * Set the state of enclosed RNBO patcher using a {@link IPreset}.
+     * @example
+     * ```js
+     * const preset = await device.getPreset();
+     * device.parametersById("gain").value = -70;
+     * device.setPreset(preset); // return to the previous value
+     * ```
+     * @public
+     */
+    setPreset(preset: IPreset): void;
+}
+
+/* Excluded from this release type: BaseEngine */
+
+/**
+ * Common Base Event class for all RNBO Events
+ * @public
+ */
+export declare abstract class BaseEvent implements IBaseEvent {
+    /* Excluded from this release type: eventTarget */
+    /* Excluded from this release type: invalid */
+    /* Excluded from this release type: source */
+    /** The scheduled time of the event */
+    time: MillisecondTime;
+    /** The type of the event. See {@link EventType} */
+    readonly type: EventType;
+    /* Excluded from this release type: __constructor */
+    serialize(): IBaseEvent;
+}
+
+/**
+ * BeatTimeEvent class to send transport beattime changes into a RNBO {@link BaseDevice | Device }
+ * @remarks
+ * Refer to our guide on {@link https://rnbo.cycling74.com/learn/musical-time-events | Events related to Musical Time}.
+ *
+ * @public
+ */
+export declare class BeatTimeEvent extends BaseEvent implements IBeatTimeEvent {
+    readonly beattime: number;
+    /** {@inheritDoc BaseEvent."type"} */
+    readonly type: EventType.BeatTimeEvent;
+    constructor(time: MillisecondTime, beattime: number);
+    serialize(): IBeatTimeEvent;
+}
+
+/**
+ * Mixin function for the CommonParameterMixin.
+ *
+ * @param baseClass - The base class to be extended
+ * @returns A child class that extends baseClass, adding the CommonParameterMixin functionality.
+ * @public
+ */
+export declare function CommonParameterMixin<TBaseClass extends Constructor>(baseClass: TBaseClass): TBaseClass & (new (...args: any[]) => CommonParameterMixin);
+
+/**
+ * The mixin base interface for all Parameters providing common functionality and attributes across
+ * all {@link ParameterType | types} of {@link Parameter | Parameters}.
+ * @public
+ */
+export declare interface CommonParameterMixin {
+    /** The unique id of the parameter */
+    readonly id: ParameterId;
+    /** The index of the parameter */
+    readonly index: number;
+    /** The name of the parameter */
+    readonly name: string;
+    /** The displayName of the parameter */
+    readonly displayName: string;
+    /** The exponent of the parameter */
+    readonly exponent: number;
+    /** Minimum possible value of the parameter */
+    readonly min: number;
+    /** Maximum possible value of the parameter */
+    readonly max: number;
+    /**
+     * The normalized value of the parameter in a range from 0-1
+     *
+     * @example
+     * ```ts
+     * // Update the current parameter value with a normalized value by simply setting the property
+     * param.normalizedValue = 0.8;
+     * ```
+     */
+    normalizedValue: number;
+    /** The steps of the parameter */
+    readonly steps: number;
+    /** The type of the parameter see {@link ParameterType} */
+    readonly type: ParameterType;
+    /** The unit of the parameter */
+    readonly unit: string;
+    /**
+     * The notification setting of the parameter for its changeEvent, which will be the same as the {@link ParameterNotificationSetting} set on the {@link BaseDevice.parameterNotificationSetting | Device}.
+     */
+    readonly notificationSetting: ParameterNotificationSetting;
+    /**
+     * In addition to capturing the events emitted by the {@link BaseDevice.parameterChangeEvent | Device}, you can subscribe to a changeEvent on the Parameter itself, allowing additional, more granular event handling.
+     * The parameter uses the same {@link ParameterNotificationSetting} as set on the {@link BaseDevice.parameterNotificationSetting | Device}.
+     *
+     * @example
+     * ```ts
+     * param.changeEvent.subscribe((value: any) => {
+     *   // the type of the value is dependent on the type of the parameter
+     * });
+     * ```
+     *
+     */
+    readonly changeEvent: EventSubject<any>;
+    /**
+     * Parameter specific conversion function to convert a normalized value to a real value
+     * see {@link ConvertFromNormalizedValueFunction}
+     *
+     * @example
+     * ```ts
+     * // this will convert someValue in the range of (0..1) to a real value according to param's specific conversion function
+     * param.convertFromNormalizedValue(someValue: number);
+     * ```
+     */
+    readonly convertFromNormalizedValue: ConvertFromNormalizedValueFunction;
+    /**
+     * Parameter specific conversion function to convert a real value to a normalized
+     * see {@link ConvertToNormalizedValueFunction}
+     *
+     * @example
+     * ```ts
+     * // this will convert someValue to a normalized value according to param's specific conversion function
+     * param.convertToNormalizedValue(someValue: number);
+     * ```
+     */
+    readonly convertToNormalizedValue: ConvertToNormalizedValueFunction;
+    /* Excluded from this release type: __set_value__ */
+    /* Excluded from this release type: __internalSetNotificationSetting */
+    /* Excluded from this release type: __internalUpdateParameterValue */
+    /* Excluded from this release type: __internalSetParameterValue */
+}
+
+/**
+ * constrain a parameter value to its range
+ * @param value - the real value to constrain
+ * @returns the constrained value
+ * @public
+ */
+declare type ConstrainParameterValueFunction = (value: number) => number;
+
+/**
+ * Mixin Constructor Helper
+ * @public
+ */
+export declare type Constructor<T = {}> = new (...args: any[]) => T;
+
+/**
+ * Conversion function to convert a normalized value to a real value
+ * @param normalizedValue - the normalized value to convert
+ * @returns the real value of the given normalized value
+ * @public
+ */
+export declare type ConvertFromNormalizedValueFunction = (normalizedValue: number) => number;
+
+/**
+ * Conversion function to convert a real value to a normalized value
+ * @param value - the real value to convert
+ * @returns the normalized value of the given real value
+ * @public
+ */
+export declare type ConvertToNormalizedValueFunction = (value: number) => number;
+
+/**
+ * The main entry point to \@rnbo/js. Use this createDevice factory function to create {@link Device | Devices} from your RNBO Patches.
+ * Refer to the guide on {@link https://rnbo.cycling74.com/learn/loading-a-rnbo-device-in-the-browser-js | Loading a RNBO Device in the Browser} for more details on how to use this function.
+ *
+ * @param parameters - The parameters used in creating a new RNBO Device (see {@link ICreateDeviceParameters})
+ * @param prevDevice - Optional previous device. Use this parameter to create a device from an existing one including state restoration. CAUTION: This makes the previous device invalid and therefore non-functional. This functionality is only useful for specific, advanced use-cases.
+ * @returns a Promise returning the created {@link Device}
+ * @public
+ */
+export declare function createDevice(parameters: ICreateDeviceParameters, prevDevice?: Device): Promise<Device>;
+
+/**
+ * Helper class for retrieved binary data from a RNBO Patcher using {@link BaseDevice.releaseDataBuffer}.
+ * @public
+ */
+export declare class DataBuffer {
+    /**
+     * The raw binary data of the DataBuffer
+     */
+    readonly buffer: ArrayBuffer;
+    private readonly _typeDesc;
+    /* Excluded from this release type: __constructor */
+    /**
+     * Retrieve the data interpreted as a WebAudio AudioBuffer.
+     * @param context - The AudioContext to use for creating a new AudioBuffer
+     */
+    getAsAudioBuffer(context: AudioContext): AudioBuffer;
+}
+
+/**
+ * Calls to {@link BaseDevice."loadDataBufferDependencies"} will return an array of load descriptions,
+ * containing the id of the buffer being loaded, a status type, and--for failures--an error.
+ * @public
+ */
+declare type DependencyLoadDescription = DependencyLoadFailedDescription | DependencyLoadSucceededDescription;
+
+declare type DependencyLoadFailedDescription = {
+    type: "fail";
+    id: ExternalDataInfo["id"];
+    error: Error;
+};
+
+declare type DependencyLoadSucceededDescription = {
+    type: "success";
+    id: ExternalDataInfo["id"];
+};
+
+/**
+ * Union Device Type for handling {@link ScriptDevice} and {@link WorkletDevice}.
+ * @public
+ */
+export declare type Device = ScriptDevice | WorkletDevice;
+
+/**
+ * Enum to identify the type of a {@link Device} via {@link BaseDevice."type"}. Also used within {@link createDevice}
+ * @public
+ */
+export declare enum DeviceType {
+    /** Used by {@link ScriptDevice} */
+    Script = "script",
+    /** Used by {@link WorkletDevice} */
+    Worklet = "worklet",
+    /** Invalid. A device becomes invalid after being reused by a call to {@link createDevice} */
+    Invalid = "invalid"
+}
+
+/* Excluded from this release type: Engine */
+
+/**
+ * Parameter Class for describing and interacting with Enum Type Parameters in RNBO
+ * Uses the CommonParameterMixin
+ * @public
+ */
+export declare class EnumParameter extends EnumParameter_base {
+    readonly type: ParameterType.Enum;
+    protected _enumValues: EnumValue[];
+    readonly changeEvent: EventSubject<number>;
+    readonly initialValue: number;
+    protected _value: number;
+    /* Excluded from this release type: __constructor */
+    /** Get an array of available enum values of the parameter */
+    get enumValues(): EnumValue[];
+    /**
+     * The actual enum value for the currently active index value.
+     * Use this to set the active index by enum value.
+     *
+     * @example
+     * ```ts
+     * console.log(param.enumValues); // => ["blue", "red", "green"]
+     * param.enumValue = "blue";
+     * console.log(param.value === 0); // => true
+     * ```
+     */
+    get enumValue(): EnumValue;
+    set enumValue(v: EnumValue);
+    /**
+     * The current selected index value of the parameter
+     *
+     * @example
+     * ```ts
+     * // Update the current index value
+     * param.value = 2
+     * ```
+     */
+    get value(): number;
+    set value(v: number);
+}
+
+declare const EnumParameter_base: ObjectConstructor & (new (...args: any[]) => CommonParameterMixin);
+
+/**
+ * Possible value of an {@link EnumParameter}
+ * @public
+ */
+export declare type EnumValue = number | string;
+
+/**
+ * Union Type for RNBO Event Classes (see MessageEvent, {@link MIDIEvent})
+ * @public
+ */
+declare type Event_2 = MessageEvent_2 | MIDIEvent | TransportEvent | TempoEvent | BeatTimeEvent | TimeSignatureEvent | PresetEvent;
+export { Event_2 as Event }
+
+/**
+ * The EventSubject class is used to enable the concept of listening and emitting evens while maintaining type safety for the
+ * subscribing listeners. The type Generic `T` hereby refers to the event parameter passed on the listeners when emitting events.
+ * @public
+ */
+export declare class EventSubject<T> {
+    protected _subscriptions: IEventListener<T>[];
+    protected _oneTimeSubscriptions: IEventListener<T>[];
+    constructor();
+    get listenerCount(): number;
+    /**
+     * Emits an event on subject.
+     * @param event - The event to emit
+     */
+    emit(event: T): void;
+    /**
+     * Add a listener callback that gets only called once and then removed from the subject.
+     * @param listener - The listener callback to subscribe
+     */
+    once(listener: IEventListener<T>): IEventSubscription;
+    /**
+     * Subscribe a listener callback for all upcoming events on the subject
+     * @param listener - The listener callback to subscribe
+     * @returns a subscription that can later be used to unsubscribe the listener, see {@link IEventSubscription}
+     */
+    subscribe(listener: IEventListener<T>): IEventSubscription;
+    /**
+     * Unsubscribe a previously added listener callback from the event
+     * @param listener - The listener callback to unsubscribe
+     */
+    unsubscribe(listener: IEventListener<T>): void;
+    /**
+     * Remove all listeners that are currently subscribed to the event
+     */
+    removeAllSubscriptions(): void;
+}
+
+/**
+ * Used internally to route events based on their target.
+ * @public
+ */
+declare type EventTarget_2 = any;
+export { EventTarget_2 as EventTarget }
+
+/**
+ * Enum used to distinguish the type of events. See {@link BaseEvent."type"}.
+ * @public
+ */
+export declare enum EventType {
+    /* Excluded from this release type: BufferTransfer */
+    /* Excluded from this release type: ClockEvent */
+    /* Excluded from this release type: DataRefEvent */
+    /**
+     * Message Event sent in and out of a RNBO Device
+     * See MessageEvent
+     */
+    MessageEvent = 3,
+    /**
+     * MIDIEvents sent in and out of a RNBO Device.
+     * See {@link MIDIEvent}
+     */
+    MIDIEvent = 4,
+    /* Excluded from this release type: ParameterEvent */
+    /**
+     * PresetEvents received from a RNBO Device.
+     * See {@link PresetEvent}
+     */
+    PresetEvent = 6,
+    /* Excluded from this release type: StartupEvent */
+    /**
+     * TransportEvents sent into a RNBO Device.
+     * See {@link TransportEvent}
+     */
+    TransportEvent = 8,
+    /**
+     * TempoEvents sent into a RNBO Device.
+     * See {@link TempoEvent}
+     */
+    TempoEvent = 9,
+    /**
+     * BeatTimeEvents sent into a RNBO Device.
+     * See {@link BeatTimeEvent}
+     */
+    BeatTimeEvent = 10,
+    /**
+     * TimeSignatureEvents sent into a RNBO Device.
+     * See {@link TimeSignatureEvent}
+     */
+    TimeSignatureEvent = 11
+}
+
+/**
+ * @public
+ */
+export declare type ExternalDataId = string;
+
+declare type ExternalDataIndex = number;
+
+/**
+ * @public
+ */
+export declare type ExternalDataInfo = ExternalDataInfoURL | ExternalDataInfoFile;
+
+/**
+ * @public
+ */
+export declare interface ExternalDataInfoBase {
+    id: ExternalDataId;
+    type: string;
+}
+
+/**
+ * @public
+ */
+export declare interface ExternalDataInfoFile extends ExternalDataInfoBase {
+    file: string;
+}
+
+/**
+ * @public
+ */
+export declare interface ExternalDataInfoURL extends ExternalDataInfoBase {
+    url: string;
+}
+
+/* Excluded from this release type: FromProcessorMessage */
+
+/* Excluded from this release type: FromProcessorMessageId */
+
+/**
+ * Interface for the {@link BaseEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface IBaseEvent {
+    /* Excluded from this release type: eventTarget */
+    /* Excluded from this release type: invalid */
+    /* Excluded from this release type: source */
+    time: MillisecondTime;
+}
+
+/* Excluded from this release type: IBaseRNBODataDesc */
+
+/* Excluded from this release type: IBaseSerializedRNBODataDesc */
+
+/**
+ * Interface for the {@link BeatTimeEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface IBeatTimeEvent extends IBaseEvent {
+    beattime: number;
+    type: EventType.BeatTimeEvent;
+}
+
+/**
+ * Interface describing the parameters passed to {@link createDevice} when attempting to create a new {@link Device}
+ * @public
+ */
+export declare interface ICreateDeviceParameters {
+    /** The AudioContext to be used by the {@link Device} */
+    context: AudioContext;
+    /** Optional options object to pass on to the {@link Device}, see {@link IDeviceOptions} */
+    options?: IDeviceOptions;
+    /** The exported patcher to use in creating the {@link Device} */
+    patcher: IPatcher;
+    /**
+     * Optional type defining the {@link DeviceType} (AudioWorklet or ScriptProcessor) to create. The default value `"auto"` lets `createDevice()` pick the correct type based on the support of the current environment.
+     */
+    type?: "auto" | DeviceType;
+}
+
+declare interface IDeserializedParamConversion {
+    applyStepsToNormalizedParameterValue: Function;
+    convertToNormalizedParameterValue: Function;
+    convertFromNormalizedParameterValue: Function;
+    getNumParameters: Function;
+    constrainParameterValue: Function;
+    isPolyphonic: boolean;
+    subpatches: IDeserializedParamConversion[];
+}
+
+declare type IDeserializedPatcherConversion = IDeserializedParamConversion & {
+    [key: string]: Function | IDeserializedParamConversion | IDeserializedParamConversion[];
+};
+
+/**
+ * Options for creating a RNBO {@link BaseDevice}
+ * @public
+ */
+export declare interface IDeviceOptions {
+    /**
+     * Set the size of the buffer used for the Web Audio ScriptProcessorNode. Applies only to {@link ScriptDevice}.
+     * default: 1024
+     */
+    bufferSize?: number;
+    /**
+     * Adjust the way the device emits {@link BaseDevice.parameterChangeEvent | ParameterChangeEvents}, see {@link ParameterNotificationSetting}.
+     * By default, set to emit a `parameterChangeEvent` whenever the value changes: `ParameterNotificationSetting.All`
+     */
+    parameterNotificationSetting?: ParameterNotificationSetting;
+}
+
+/* Excluded from this release type: IEngineProcessorEventSubjects */
+
+/* Excluded from this release type: IEnumParameterArgs */
+
+/**
+ * Generic Interface used for ListenerCallbacks alongside the EventSubject class.
+ * The IEventListener is hereby used to safely type the callback and the passed on event parameter.
+ * @public
+ */
+export declare interface IEventListener<T> {
+    (event: T): any;
+}
+
+/**
+ * Interface describing the return value of a call to {@link EventSubject.subscribe}.
+ * @public
+ */
+export declare interface IEventSubscription {
+    /** Unsubscribe the listener callback from the event */
+    unsubscribe: () => void;
+}
+
+/* Excluded from this release type: IFromProcessorGetPresetResponse */
+
+/* Excluded from this release type: IFromProcessorOutgoingEvent */
+
+/* Excluded from this release type: IFromProcessorReleaseBuffer */
+
+/* Excluded from this release type: IFromProcessorSetPatcher */
+
+/* Excluded from this release type: IFromProcessorTransferBuffer */
+
+/**
+ * Interface for the MessageEvent and the serialized version of it.
+ * @public
+ */
+export declare interface IMessageEvent extends IBaseEvent {
+    objectId: MessageTag;
+    payload: MessagePayload;
+    tag: MessageTag;
+    type: EventType.MessageEvent;
+}
+
+/**
+ * Interface for the {@link MIDIEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface IMIDIEvent extends IBaseEvent {
+    channel: number;
+    data: MIDIData;
+    port: number;
+    type: EventType.MIDIEvent;
+}
+
+/* Excluded from this release type: INumberParameterArgs */
+
+/* Excluded from this release type: IParameterArgs */
+
+/**
+ * Parameter Description of a generated RNBO Patcher
+ * @public
+ */
+export declare interface IParameterDescription {
+    type: string;
+    index: number;
+    name: string;
+    paramId: string;
+    minimum: number;
+    maximum: number;
+    exponent: number;
+    steps: number;
+    initialValue: number;
+    isEnum: boolean;
+    enumValues: string[];
+    displayName: string;
+    unit: string;
+    initialized: boolean;
+    debug: boolean;
+    saveable: boolean;
+    transmittable: boolean;
+    visible: boolean;
+    signalIndex: number;
+    ioType: string;
+}
+
+declare interface IParameterInfo {
+    displayName: string;
+    enumValues: string[] | number[];
+    exponent: number;
+    id: ParameterId;
+    index: number;
+    initialValue: any;
+    ioType: number;
+    isEnum: boolean;
+    min: number;
+    max: number;
+    name: string;
+    signalIndex: number;
+    steps: number;
+    type: number;
+    unit: string;
+    visible: boolean;
+}
+
+declare interface IParameterScalingInfo {
+    convertFromNormalized: ConvertFromNormalizedValueFunction;
+    convertToNormalized: ConvertToNormalizedValueFunction;
+    constrainParameterValue: ConstrainParameterValueFunction;
+}
+
+/**
+ * Interface describing the generated RNBO Patcher Object
+ * @public
+ */
+export declare interface IPatcher {
+    /** Patcher Description */
+    desc: IPatcherDescription;
+    presets?: {
+        name: string;
+        preset: IPreset;
+    }[];
+    src: Array<IPatcherSrc>;
+}
+
+/**
+ * Patcher Description of a generated RNBO Patcher
+ * @public
+ * */
+export declare interface IPatcherDescription {
+    /** number of input channels on the patcher */
+    numInputChannels: number;
+    /** number of output channels on the patcher */
+    numOutputChannels: number;
+    /** number of MIDI input ports on the patcher */
+    numMidiInputPorts: number;
+    /** number of MIDI output ports on the patcher */
+    numMidiOutputPorts: number;
+    /** number of parameters */
+    numParameters: number;
+    /** number of signal input parameters */
+    numSignalInParameters: number;
+    /** number of signal output parameters (aka. additional named audio outputs) */
+    numSignalOutParameters: number;
+    /** serial number pf patcher, used for state restoration */
+    patcherSerial: number;
+    /** Parameter description see {@link IParameterDescription} */
+    parameters: IParameterDescription[];
+    /* Excluded from this release type: paramConversion */
+    /** a list of external dataref ids */
+    externalDataRefs: ExternalDataInfo[];
+    /** a list of inports */
+    inports: MessagePort_2[];
+    /** a list of outports */
+    outports: MessagePort_2[];
+    /** Patcher Options */
+    options: IPatcherOptions;
+    meta: {
+        /** Version of Max the Patcher was exported with */
+        maxversion?: string;
+        /** Version of RNBO the Patcher was exported with */
+        rnboversion: string;
+    };
+    /**
+     * @deprecated since version 0.18.0, see meta.rnboversion
+     */
+    rnboVersion?: string;
+}
+
+/**
+ * Option Settings of a generated RNBO Patcher
+ * @public
+ * */
+export declare interface IPatcherOptions {
+    classname: string;
+    minifyOutput: boolean;
+}
+
+/* Excluded from this release type: IPatcherParamConversion */
+
+export declare interface IPatcherSrc {
+    code: string;
+    compression?: "zlib";
+    encoding?: "base64" | "utf8" | "utf-8";
+    type: "wasm" | "js";
+}
+
+/**
+ * Collection of parameter values as a RNBO Patcher Preset, mapping:
+ *
+ * - a parameter name to a numerical value
+ *
+ * - a parameter name to a list of numerical values
+ *
+ * - a subpatcher name to a sub preset (subpatcher or object state)
+ *
+ * - a subpatcher name a list of sub presets (for polyphonic subpatchers)
+ * @public
+ */
+export declare interface IPreset {
+    [propName: string]: number | Array<number> | IPreset | Array<IPreset>;
+}
+
+/**
+ * Interface for the {@link PresetEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface IPresetEvent extends IBaseEvent {
+    action: RNBOPresetEventAction;
+    type: EventType.PresetEvent;
+    preset?: IPreset;
+}
+
+/* Excluded from this release type: IRNBOClockEvent */
+
+/* Excluded from this release type: IRNBODataRefEvent */
+
+/* Excluded from this release type: IRNBOFloat32AudioBuffer */
+
+/* Excluded from this release type: IRNBOParameterEvent */
+
+/* Excluded from this release type: IRNBOStartupEvent */
+
+/* Excluded from this release type: IRNBOTypedArrayBuffer */
+
+/**
+ * Interface for the {@link TempoEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface ITempoEvent extends IBaseEvent {
+    tempo: number;
+    type: EventType.TempoEvent;
+}
+
+/**
+ * Interface for the {@link TimeSignatureEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface ITimeSignatureEvent extends IBaseEvent {
+    numerator: number;
+    denominator: number;
+    type: EventType.TimeSignatureEvent;
+}
+
+/* Excluded from this release type: IToProcesserGetPreset */
+
+/* Excluded from this release type: IToProcesserReleaseBuffer */
+
+/* Excluded from this release type: IToProcesserSetPatcher */
+
+/* Excluded from this release type: IToProcesserSetPreset */
+
+/* Excluded from this release type: IToProcessorScheduleEvent */
+
+/* Excluded from this release type: IToProcessorTransferBuffer */
+
+/**
+ * Interface for the {@link TransportEvent} and the serialized version of it.
+ * @public
+ */
+export declare interface ITransportEvent extends IBaseEvent {
+    state: TransportState;
+    type: EventType.TransportEvent;
+}
+
+/**
+ * WorkletNode of a {@link WorkletDevice} extending {@link https://developer.mozilla.org/en-US/docs/Web/API/AudioWorkletNode | AudioWorkletNode}
+ * @public
+ */
+export declare interface IWorkletNode extends AudioWorkletNode {
+    /* Excluded from this release type: loadPatcher */
+}
+
+/**
+ * MessageEvent class to send Message Events into a RNBO {@link BaseDevice | Device } or receive events from a {@link BaseDevice | Device }.
+ * @remarks
+ * Refer to our article on {@link https://rnbo.cycling74.com/learn/sending-and-receiving-messages-inlets-outlets | Sending and Receiving Messages} to learn more.
+ *
+ * @public
+ */
+declare class MessageEvent_2 extends BaseEvent implements IMessageEvent {
+    /** The tag of the Message. See {@link MessageTag} */
+    readonly tag: MessageTag;
+    /** The optional id of the target object of the Message */
+    readonly objectId: MessageTag;
+    /** The payload data of the Message. See {@link MessagePayload} */
+    readonly payload: MessagePayload;
+    /** {@inheritDoc BaseEvent."type"} */
+    readonly type: EventType.MessageEvent;
+    constructor(time: MillisecondTime, tag: MessageTag, payload?: MessagePayload, objectId?: MessageTag, eventTarget?: EventTarget_2);
+    serialize(): IMessageEvent;
+}
+export { MessageEvent_2 as MessageEvent }
+
+/**
+ * The description of a message endpoint
+ * @public */
+export declare type MessageInfo = {
+    tag: MessageTag;
+    type: MessagePortType;
+    meta?: any;
+};
+
+/**
+ * The payload of a MessageEvent
+ * @public
+ */
+export declare type MessagePayload = number | number[] | undefined;
+
+declare type MessagePort_2 = {
+    tag: MessageTag;
+    meta?: any;
+};
+
+/**
+ * The type of a message endpoint
+ * @public */
+export declare enum MessagePortType {
+    Inport = 0,
+    Outport = 1,
+    Undefined = 2
+}
+
+/**
+ * The tag / identifier of a MessageEvent
+ * @public */
+export declare type MessageTag = string;
+
+/**
+ * A single byte of {@link MIDIData}
+ * @public
+ */
+export declare type MIDIByte = number | undefined;
+
+/**
+ * The data of a {@link MIDIEvent} consisting out of 3 {@link MIDIByte | MIDIBytes }
+ * @public
+ */
+export declare type MIDIData = [MIDIByte] | [MIDIByte, MIDIByte] | [MIDIByte, MIDIByte, MIDIByte];
+
+/**
+ * MIDIEvent class to send MIDI Events into a RNBO {@link BaseDevice | Device } or receive events from a {@link BaseDevice | Device }.
+ * @remarks
+ * Refer to our article on {@link https://rnbo.cycling74.com/learn/sending-and-receiving-midi | Sending and Receiving MIDI} to learn more.
+ *
+ * @public
+ */
+export declare class MIDIEvent extends BaseEvent implements IMIDIEvent {
+    readonly status: number;
+    /** The MIDI Channel */
+    readonly channel: number;
+    /** The MIDI Port */
+    readonly port: number;
+    /** The MIDI Data - see {@link MIDIData} */
+    readonly data: MIDIData;
+    /** The amount of actually set bytes in the {@link MIDIData} of the event */
+    readonly length: number;
+    /** {@inheritDoc BaseEvent."type"} */
+    readonly type: EventType.MIDIEvent;
+    constructor(time: MillisecondTime, port: number, data: MIDIData, eventTarget?: EventTarget_2);
+    serialize(): IMIDIEvent;
+}
+
+/**
+ * All time is measured in milliseconds
+ * @public
+ */
+export declare type MillisecondTime = number;
+
+/**
+ * Parameter Class for describing and interacting with Number (Float) Type Parameters in RNBO
+ * Uses the CommonParameterMixin
+ * @public
+ */
+export declare class NumberParameter extends NumberParameter_base {
+    /** The type of the parameter see {@link ParameterType} */
+    readonly type: ParameterType.Number;
+    readonly changeEvent: EventSubject<number>;
+    readonly initialValue: number;
+    protected _value: number;
+    /* Excluded from this release type: __constructor */
+    /**
+     * The current absolute value of the parameter
+     *
+     * @example
+     * ```ts
+     * // Update the current parameter value
+     * param.value = 2
+     * ```
+     */
+    get value(): number;
+    set value(v: number);
+}
+
+declare const NumberParameter_base: ObjectConstructor & (new (...args: any[]) => CommonParameterMixin);
+
+/**
+ * Union Type of all available Parameter Classes.
+ * @public
+ */
+export declare type Parameter = BangParameter | EnumParameter | NumberParameter;
+
+/**
+ * Type of the ID of a parameter
+ * @public
+ */
+export declare type ParameterId = string;
+
+/* Excluded from this release type: ParameterInterface */
+
+declare type ParameterInterfaceId = ReturnType<typeof uniqueId>;
+
+declare type ParameterInterfaceOptions = {
+    notificationSetting: ParameterNotificationSetting;
+};
+
+/**
+ * Enum defining the available options for the parameter change event setting of a {@link BaseDevice.parameterChangeEvent | Device}.
+ * @public
+ */
+export declare enum ParameterNotificationSetting {
+    /**
+     * Emits {@link BaseDevice.parameterChangeEvent | ParameterChangeEvents} whenever the value changes. This includes
+     * values changes from the outside by setting the <a href="./CommonParameterMixin#value">param.value</a> of a parameter
+     * and internal changes to the value of the parameter.
+     */
+    All = 0,
+    /**
+     * Emits {@link BaseDevice.parameterChangeEvent | ParameterChangeEvents} only when the value of the parameter
+     * has been updated by the device itself. This means that setting <a href="./CommonParameterMixin#value">param.value</a> does not trigger an immediate event.
+     */
+    Internal = 1
+}
+
+/**
+ * Enum used to distinguish the type of a Parameter.
+ * @public
+ */
+export declare enum ParameterType {
+    Number = 0,
+    Bang = 1,
+    /* Excluded from this release type: List */
+    /* Excluded from this release type: Signal */
+    /* Excluded from this release type: Count */
+    Enum = 5
+}
+
+/**
+ * PresetEvent class to receive preset touched events from RNBO {@link BaseDevice | Device }
+ *
+ * @public
+ */ export declare class PresetEvent extends BaseEvent implements IPresetEvent {
+    readonly action: RNBOPresetEventAction;
+    readonly type: EventType.PresetEvent;
+    readonly preset: IPreset;
+    /* Excluded from this release type: __constructor */
+    serialize(): IPresetEvent;
+}
+
+/* Excluded from this release type: RNBOClockEvent */
+
+/* Excluded from this release type: RNBODataDesc */
+
+/* Excluded from this release type: RNBODataRefEvent */
+
+/* Excluded from this release type: RNBODataRefEventAction */
+
+/* Excluded from this release type: RNBODataType */
+
+/* Excluded from this release type: RNBOEvent */
+
+/* Excluded from this release type: RNBOFloat32AudioBuffer */
+
+/* Excluded from this release type: RNBOParameterEvent */
+
+/**
+ * @public
+ */
+export declare enum RNBOPresetEventAction {
+    /* Excluded from this release type: Set */
+    Touched = 2
+}
+
+/* Excluded from this release type: RNBOStartupEvent */
+
+/* Excluded from this release type: RNBOTypedArrayBuffer */
+
+/**
+ * RNBO Device using a WebAudio ScriptProcessorNode for its processing.
+ *
+ * @remarks
+ * ScriptDevices can be created using the {@link createDevice} factory function.
+ * Please also refer to the article on {@link https://rnbo.cycling74.com/learn/loading-a-rnbo-device-in-the-browser-js | Loading a RNBO device in the Browser} for more information.
+ *
+ * @public
+ * */
+export declare class ScriptDevice extends BaseDevice {
+    /* Excluded from this release type: _engine */
+    readonly bufferSize: number;
+    protected _node?: ScriptProcessorNode;
+    /* Excluded from this release type: __constructor */
+    private _onAudioProcess;
+    private _process;
+    private _setCurrentTime;
+    /**
+     * The WebAudio {@link https://developer.mozilla.org/en-US/docs/Web/API/ScriptProcessorNode | ScriptProcessorNode of the device.}
+     * See {@link BaseDevice.node} for more info
+     */
+    get node(): ScriptProcessorNode;
+    /* Excluded from this release type: setPatcher */
+}
+
+/* Excluded from this release type: SerializedRNBODataDesc */
+
+/* Excluded from this release type: StartupPhase */
+
+/* Excluded from this release type: SyncEngine */
+
+/**
+ * TempoEvent class to send tempo changes into a RNBO {@link BaseDevice | Device }
+ * @remarks
+ * Refer to our guide on {@link https://rnbo.cycling74.com/learn/musical-time-events | Events related to Musical Time}.
+ * @public
+ */
+export declare class TempoEvent extends BaseEvent implements ITempoEvent {
+    readonly tempo: number;
+    /** {@inheritDoc BaseEvent."type"} */
+    readonly type: EventType.TempoEvent;
+    constructor(time: MillisecondTime, tempo: number);
+    serialize(): ITempoEvent;
+}
+
+/**
+ * Constant representing the time "Now"
+ * @public
+ */
+export declare const TimeNow: MillisecondTime;
+
+/**
+ * TimeSignatureEvent class to send time signature changes into a RNBO {@link BaseDevice | Device }
+ * @remarks
+ * Refer to our guide on {@link https://rnbo.cycling74.com/learn/musical-time-events | Events related to Musical Time}.
+ */
+export declare class TimeSignatureEvent extends BaseEvent implements ITimeSignatureEvent {
+    readonly numerator: number;
+    readonly denominator: number;
+    /** {@inheritDoc BaseEvent."type"} */
+    readonly type: EventType.TimeSignatureEvent;
+    constructor(time: MillisecondTime, numerator: number, denominator: number);
+    serialize(): ITimeSignatureEvent;
+}
+
+/* Excluded from this release type: ToProcessorMessage */
+
+/* Excluded from this release type: ToProcessorMessageId */
+
+/**
+ * TransportEvent class to send transport state changes into a RNBO {@link BaseDevice | Device }
+ * @remarks
+ * Refer to our guide on {@link https://rnbo.cycling74.com/learn/musical-time-events | Events related to Musical Time}.
+ * @public
+ */
+export declare class TransportEvent extends BaseEvent implements ITransportEvent {
+    readonly state: TransportState;
+    /** {@inheritDoc BaseEvent."type"} */
+    readonly type: EventType.TransportEvent;
+    constructor(time: MillisecondTime, state: TransportState);
+    serialize(): ITransportEvent;
+}
+
+/**
+ * The transport state
+ * @public
+ */
+export declare enum TransportState {
+    STOPPED = 0,
+    RUNNING = 1
+}
+
+declare const uniqueId: () => number;
+
+/**
+ * The version of \@rnbo/js
+ * @public
+ */
+export declare const version: string;
+
+/* Excluded from this release type: WASMEngine */
+
+declare class WebAudioTimeConverter {
+    fromRNBOtime(time: MillisecondTime): number;
+    toRNBOtime(time: number): MillisecondTime;
+}
+
+/**
+ * RNBO Device using AudioWorklets for its processing.
+ *
+ * @remarks
+ * WorkletDevices can be created using the {@link createDevice} factory function.
+ * Please also refer to the article on {@link https://rnbo.cycling74.com/learn/loading-a-rnbo-device-in-the-browser-js | Loading a RNBO device in the Browser} for more information.
+ *
+ * @public
+ * */
+export declare class WorkletDevice extends BaseDevice {
+    /* Excluded from this release type: _engine */
+    protected _node?: IWorkletNode;
+    /* Excluded from this release type: __constructor */
+    protected _buildParamDescriptor(): string;
+    /**
+     * The WebAudio WorkletNode of the device of type {@link IWorkletNode}.
+     * See {@link BaseDevice.node} for more info
+     */
+    get node(): IWorkletNode;
+    /* Excluded from this release type: setPatcher */
+}
+
+export { }