/// <reference types="node" />
import * as Api from './api';
import { Readable, Writable } from 'stream';
import { ArrayCombine } from './utility-types';
import { Logger, LoggerOptions } from 'pino';
import { WsState } from './ws';
import { getMacros } from './macros';
declare const customEventCodes: readonly ["on_audio_data", "on_image_data"];
declare const customEventNames: readonly ["onAudioData", "onImageData"];
declare type StreamGetterOptions = {
    pcm: boolean | {
        resample?: boolean | SamplingRate;
        stabilize?: boolean | number;
    };
};
declare type StreamGetter = (options?: StreamGetterOptions) => Readable;
interface CustomEventAudioData {
    event: Api.EventStreamStart;
    opusInfo: OpusInfo;
    getStream: StreamGetter;
}
interface CustomEventImageData {
    event: Api.EventImage;
}
declare type CustomEventList = [CustomEventAudioData, CustomEventImageData];
declare type EventCodes = [...typeof Api.eventCodes, ...typeof customEventCodes];
declare type EventCode = EventCodes[number];
declare type EventNames = [...typeof Api.eventNames, ...typeof customEventNames];
declare type EventName = EventNames[number];
declare type EventList = [...Api.EventList, ...CustomEventList];
declare type EventMap = ArrayCombine<EventCodes, EventList>;
declare type EventNameToCode = ArrayCombine<EventNames, EventCodes>;
declare type EventCallback<T extends EventCode> = (data: EventMap[T]) => void;
declare type EventCallbacks = {
    [P in EventCode]?: EventCallback<P>;
};
declare type Event<T extends EventCode> = (cb: EventCallback<T>) => void;
declare type Events = {
    [P in EventName]: Event<EventNameToCode[P]>;
};
declare const customCommandCodes: readonly ["send_audio_data", "send_image_data"];
declare const customCommandNames: readonly ["sendAudioData", "sendImageData"];
interface CustomCommandSendAudioDataRequest {
    streamId: number;
    frameSize: number;
}
interface CustomCommandSendAudioDataResponse {
    stream: Writable;
}
interface CustomCommandSendImageDataRequest {
    imageId: number;
    fullSizeData: Buffer;
    thumbnailData: Buffer;
}
interface CustomCommandSendImageDataResponse {
    (): Promise<void>;
}
declare type CustomCommandList = [
    [
        CustomCommandSendAudioDataRequest,
        CustomCommandSendAudioDataResponse
    ],
    [
        CustomCommandSendImageDataRequest,
        CustomCommandSendImageDataResponse
    ]
];
declare type CommandCodes = [...typeof Api.commandCodes, ...typeof customCommandCodes];
declare type CommandCode = CommandCodes[number];
declare type CommandNames = [...typeof Api.commandNames, ...typeof customCommandNames];
declare type CommandName = CommandNames[number];
declare type CommandList = [...Api.CommandList, ...CustomCommandList];
declare type CommandMap = ArrayCombine<CommandCodes, CommandList>;
declare type CommandNameToCode = ArrayCombine<CommandNames, CommandCodes>;
declare type Command<T extends CommandCode> = (request: Omit<CommandMap[T][0], 'command'>, timeout?: number) => Promise<CommandMap[T][1]>;
declare type Commands = {
    [P in CommandName]: Command<CommandNameToCode[P]>;
};
declare function isCommandSendAudioData(arg: any, command: CommandCode): arg is CustomCommandSendAudioDataRequest;
declare function isCommandSendImageData(arg: any, command: CommandCode): arg is CustomCommandSendImageDataRequest;
declare type AwaitFilterCallback<T extends EventCode> = (data: EventMap[T]) => boolean;
declare type Await<T extends EventName> = (filter: AwaitFilterCallback<EventNameToCode[T]> | boolean, timeout: number) => Promise<EventMap[EventNameToCode[T]]>;
declare type Awaits = {
    [P in EventName]: Await<P>;
};
declare type Zello = {
    name: string;
    ctl: Readonly<Ctl>;
    events: Readonly<Events>;
    commands: Readonly<Commands>;
    awaits: Readonly<Awaits>;
    macros: Readonly<ReturnType<typeof getMacros>>;
    logger: Logger;
};
declare type ZelloMacro = Omit<Zello, 'macros'>;
declare type Script<TReturn> = ((props: Readonly<Zello>) => Generator<Promise<any>, TReturn, any>) | ((props: Readonly<Zello>) => TReturn);
declare function isScript(arg: any): arg is Script<unknown>;
declare function isScriptGenerator<T, TReturn, TNext>(arg: any): arg is Generator<T, TReturn, TNext>;
declare type Macro<T> = (props: Omit<Zello, 'macros'>) => T;
declare type Options = {
    logger: LoggerOptions | Logger;
    name: string;
};
declare function isOptions(arg: any): arg is Options;
interface Ctl {
    close: () => Promise<void>;
    status: () => WsState;
    run: <R extends any = void>(script: Script<R>) => Promise<R>;
}
declare type ServerAddress = string;
declare function isServerAddress(arg: any): arg is ServerAddress;
declare function isPromise(arg: any): arg is Promise<any>;
declare type OpusInfo = {
    channels: number;
    inputSampleRate: number;
    framesPerPacket: number;
    frameSize: number;
};
declare const samplingRates: readonly [8000, 12000, 16000, 24000, 48000];
declare type SamplingRate = typeof samplingRates[number];
declare const frameSizes: readonly [2.5, 5, 10, 20, 40, 60];
declare type FrameSize = typeof frameSizes[number];
declare type Channels = 1 | 2;
declare type FFmpegArgs = string[];
declare type DeferredPromise<T> = {
    resolve: (arg: T) => void;
    reject?: any;
};
export { Events, Commands, Awaits, CommandCode, CommandMap, isCommandSendAudioData, isCommandSendImageData, EventCallbacks, EventNameToCode, EventName, EventCode, Event, Await, EventMap, Command, Macro, Script, Options, Ctl, isServerAddress, isScript, isScriptGenerator, isOptions, isPromise, Zello, ZelloMacro, StreamGetter, OpusInfo, DeferredPromise, samplingRates, SamplingRate, FFmpegArgs, frameSizes, FrameSize, Channels, StreamGetterOptions, };