import { OpusGetRequest, OpusSetRequest } from './opus.js';
export interface IWorkerRequest<Data, Response> {
    data: Data;
    _response?: RequestResponse<Response>;
    transfer?: ArrayBuffer[];
    requestId: RequestId;
}
export type CodecId = string;
export interface IRequestResponseSuccess<T> {
    requestId: RequestId;
    value: T;
}
export type RequestResponse<T> = IRequestResponseSuccess<T> | {
    requestId: RequestId;
    failures: string[];
};
export type RequestId = ReturnType<typeof getRequestId>;
export interface ICreateEncoderOptions {
    sampleRate: number;
    channels: number;
    application: number;
    outBufferLength: number;
    pcmBufferLength: number;
}
export interface IOpusGetRequest extends IWorkerRequest<OpusGetRequest, number> {
    type: RequestType.OpusGetRequest;
}
export declare function getFromEncoder(data: OpusGetRequest): IOpusGetRequest;
export interface IOpusSetRequest extends IWorkerRequest<OpusSetRequest, boolean> {
    type: RequestType.OpusSetRequest;
}
export declare function setToEncoder(data: OpusSetRequest): IOpusSetRequest;
export interface ICreateEncoder extends IWorkerRequest<ICreateEncoderOptions, CodecId> {
    encoderId: CodecId;
    type: RequestType.CreateEncoder;
}
export interface ICreateDecoderOptions {
    sampleRate: number;
    channels: number;
    frameSize: number;
}
export interface ICreateDecoder extends IWorkerRequest<ICreateDecoderOptions, CodecId> {
    decoderId: CodecId;
    type: RequestType.CreateDecoder;
}
export declare function createDecoder({ sampleRate, channels, frameSize }: ICreateDecoderOptions): ICreateDecoder;
export interface IDestroyEncoderOptions {
    encoderId: CodecId;
}
export interface IDestroyEncoder extends IWorkerRequest<IDestroyEncoderOptions, null> {
    type: RequestType.DestroyEncoder;
}
export declare function destroyEncoder(data: IDestroyEncoderOptions): IDestroyEncoder;
export interface IDrainRingBufferResult {
}
export declare enum RequestType {
    CreateEncoder = 0,
    CreateDecoder = 1,
    EncodeFloat = 2,
    DecodeFloat = 3,
    DestroyEncoder = 4,
    InitializeWorker = 5,
    DestroyDecoder = 6,
    OpusGetRequest = 7,
    OpusSetRequest = 8
}
export interface IInitializeWorker extends IWorkerRequest<IInitializeWorkerOptions, null> {
    type: RequestType.InitializeWorker;
}
export interface IInitializeWorkerOptions {
    wasmFileHref: string;
}
export declare function initializeWorker(data: IInitializeWorkerOptions): IInitializeWorker;
export interface IDestroyDecoderOptions {
    decoderId: CodecId;
}
export interface IDestroyDecoder extends IWorkerRequest<IDestroyDecoderOptions, null> {
    type: RequestType.DestroyDecoder;
}
export declare function destroyDecoder(data: IDestroyDecoderOptions): IDestroyDecoder;
export interface IDecodeFloatOptions {
    decoderId: CodecId;
    decodeFec?: number;
    encoded: ArrayBuffer;
}
export interface IDecodeFloatResult {
    decoded: ArrayBuffer;
}
export interface IDecodeFloat extends IWorkerRequest<IDecodeFloatOptions, IDecodeFloatResult> {
    type: RequestType.DecodeFloat;
}
export declare function decodeFloat(data: IDecodeFloatOptions): IDecodeFloat;
export interface IEncodeFloatResult {
    /**
     * if null, it means the data was written to the ring buffer, but not yet submitted
     */
    encoded: {
        buffer: ArrayBuffer;
        /**
         * duration in milliseconds
         */
        duration: number;
    } | null;
}
export interface IEncodeFloat extends IWorkerRequest<IEncodeFloatOptions, IEncodeFloatResult> {
    type: RequestType.EncodeFloat;
}
export interface IEncodeFloatOptions {
    encoderId: CodecId;
    maxDataBytes: number;
    /**
     * if null, it will try to drain the ring buffer for the data
     * that has been queued
     */
    input: {
        pcm: Float32Array<ArrayBuffer>;
    } | null;
}
export type RequestResponseType<T> = T extends IWorkerRequest<unknown, infer R> ? R : never;
export type WorkerRequest = IInitializeWorker | IEncodeFloat | ICreateEncoder | ICreateDecoder | IDestroyDecoder | IDecodeFloat | IDestroyEncoder | IOpusGetRequest | IOpusSetRequest;
declare function getRequestId(): string;
export declare function createEncoder(data: ICreateEncoderOptions): ICreateEncoder;
export declare function encodeFloat(data: IEncodeFloatOptions): IEncodeFloat;
export {};
//# sourceMappingURL=actions.d.ts.map