/// <reference types="node" />
/// <reference types="node" />
import { ChunkStreamSession, Message, MessageData } from "./chunk-stream";
import * as net from 'net';
import { Subject } from "rxjs";
import * as FLV from '@astronautlabs/flv';
export declare class VideoMessageData extends MessageData {
    tag: FLV.VideoTag;
}
export declare class AudioMessageData extends MessageData {
    tag: FLV.AudioTag;
}
export declare enum UserControlMessageType {
    StreamBegin = 0,
    StreamEOF = 1,
    StreamDry = 2,
    SetBufferLength = 3,
    StreamIsRecorded = 4,
    PingRequest = 6,
    PingResponse = 7
}
/**
 * Defines the chunk streams that various kinds of messages are sent on.
 * Note that this is completely arbitrary (except for chunk stream 2).
 * Other implementations differ on which chunk stream IDs are used, implementations
 * should not depend on this.
 */
export declare enum ChunkStreams {
    /**
     * Used for Command messages (RTMP§7.2)
     */
    Invoke = 3,
    /**
     * Used for audio data
     */
    Audio = 4,
    /**
     * Used for video data
     */
    Video = 5,
    /**
     * Dedicated chunk stream for AV control operations (play/pause/publish/etc)
     * Stole the idea from ffmpeg
     */
    AvInvoke = 6
}
export declare const CommandParameterCount: {
    _result: number;
    _error: number;
    onStatus: number;
    releaseStream: number;
    getStreamLength: number;
    getMovLen: number;
    FCPublish: number;
    FCUnpublish: number;
    FCSubscribe: number;
    onFCPublish: number;
    connect: number;
    call: number;
    createStream: number;
    close: number;
    play: number;
    play2: number;
    deleteStream: number;
    closeStream: number;
    receiveAudio: number;
    receiveVideo: number;
    publish: number;
    seek: number;
    pause: number;
};
export declare class CommandAMF0Data<T extends object = {}> extends MessageData {
    private $args;
    get commandName(): string;
    set commandName(value: string);
    get transactionId(): number;
    set transactionId(value: number);
    get commandObject(): T;
    set commandObject(value: T);
    get parameters(): any[];
    set parameters(value: any[]);
    inspect(): string;
}
export declare class DataAMF3Data extends MessageData {
    private $name;
    get name(): string;
    set name(value: string);
    inspect(): string;
}
export declare class DataAMF0Data extends MessageData {
    private $name;
    get name(): string;
    set name(value: string);
    inspect(): string;
}
export interface OnMetaData {
    audiosamplerate: number;
    stereo: boolean;
    width: number;
    height: number;
    framerate: number;
}
export declare class SetDataFrameData extends DataAMF0Data {
    constructor(...args: any[]);
    private $key;
    private $value;
    get key(): string;
    set key(value: string);
    get value(): any;
    set value(value: any);
}
export declare class ClearDataFrameData extends DataAMF0Data {
    constructor(...args: any[]);
    private $metadata;
    get metadata(): any;
    set metadata(value: any);
}
export declare class RtmpSampleAccessData extends DataAMF0Data {
    constructor(...args: any[]);
    private $audioRestricted;
    private $videoRestricted;
    get audioRestricted(): boolean;
    set audioRestricted(value: boolean);
    get videoRestricted(): boolean;
    set videoRestricted(value: boolean);
}
export declare class CommandAMF3Data<T extends object = {}> extends MessageData {
    private $args;
    get commandName(): string;
    set commandName(value: string);
    get transactionId(): number;
    set transactionId(value: number);
    get commandObject(): T;
    set commandObject(value: T);
    get parameters(): any[];
    set parameters(value: any[]);
    inspect(): string;
}
export declare enum AudioCodecFlags {
    SUPPORT_SND_NONE = 1,
    SUPPORT_SND_ADPCM = 2,
    SUPPORT_SND_MP3 = 4,
    SUPPORT_SND_INTEL = 8,
    SUPPORT_SND_UNUSED = 16,
    SUPPORT_SND_NELLY8 = 32,
    SUPPORT_SND_G711A = 128,
    SUPPORT_SND_G711U = 256,
    SUPPORT_SND_NELLY16 = 512,
    SUPPORT_SND_AAC = 1024,
    SUPPORT_SND_SPEEX = 2048,
    SUPPORT_SND_ALL = 4095
}
export declare enum VideoCodecFlags {
    SUPPORT_VID_UNUSED = 1,
    SUPPORT_VID_JPEG = 2,
    SUPPORT_VID_SORENSON = 4,
    SUPPORT_VID_HOMEBREW = 8,
    SUPPORT_VID_VP6 = 16,
    SUPPORT_VID_VP6ALPHA = 32,
    SUPPORT_VID_HOMEBREWV = 64,
    SUPPORT_VID_H264 = 128,
    SUPPORT_VID_ALL = 255
}
export declare enum VideoFunctionFlags {
    SUPPORT_VID_CLIENT_SEEK = 1
}
export declare enum ObjectEncoding {
    AMF0 = 0,
    AMF3 = 3
}
export interface ConnectCommandObject {
    app: string;
    flashver: string;
    swfUrl: string;
    tcUrl: string;
    fpad: boolean;
    audioCodecs: number;
    videoCodecs: number;
    videoFunction: number;
    pageUrl: string;
    objectEncoding: number;
}
export declare class UnknownMessageData extends MessageData {
    messageType: number;
    length: number;
    timestamp: number;
    messageStreamId: number;
    $marker: any;
}
export declare class UserControlData extends MessageData {
    eventType: number;
}
export declare class StreamBeginEventData extends UserControlData {
    streamID: number;
}
export declare class StreamEndEventData extends UserControlData {
    streamID: number;
}
export declare class StreamDryEventData extends UserControlData {
    streamID: number;
}
export declare class SetBufferLengthEventData extends UserControlData {
    streamID: number;
    bufferLength: number;
}
export declare class StreamIsRecordedEventData extends UserControlData {
    streamID: number;
}
export declare class PingRequestData extends UserControlData {
    timestamp: number;
}
export declare class PingResponseData extends UserControlData {
    timestamp: number;
}
/**
 * Represents a media stream. Subclass and override the command methods to
 * add behavior.
 */
export declare class ServerStream {
    readonly session: Session;
    readonly id: number;
    constructor(session: Session, id: number);
    destroyed: Subject<void>;
    messageReceived: Subject<Message>;
    dataReceived: Subject<DataAMF3Data | DataAMF0Data>;
    notifyBegin(): void;
    notifyDry(): void;
    notifyEnd(): void;
    dispose(): void;
    receiveData(data: DataAMF0Data | DataAMF3Data): void;
    receiveCommand(commandName: string, transactionId: number, commandObject: any, parameters: any[]): Promise<void>;
    receiveMessage(message: Message): void;
}
export interface RPCOptions {
    /**
     * Whether this RPC call is enabled or not. Defaults to true.
     */
    enabled?: boolean;
    /**
     * Whether a _result should be sent for this RPC call. Default is true.
     */
    isVoid?: boolean;
}
export declare function RPC(options?: RPCOptions): {
    (target: Function): void;
    (target: Object, propertyKey: string | symbol): void;
};
export declare class ServerControlStream extends ServerStream {
    constructor(session: Session);
    receiveCommand(commandName: string, transactionId: number, commandObject: any, parameters: any[]): Promise<void>;
}
export interface Status {
    level: 'status' | 'error';
    code: string;
    description: string;
}
export declare class ServerMediaStream extends ServerStream {
    sendStatus(status: Status): void;
    notifyBegin(): void;
    metadata: Record<string, any>;
    metadataChanged: Subject<Record<string, any>>;
    sampleAccessRestrictionsChanged: Subject<{
        audioRestricted: boolean;
        videoRestricted: boolean;
    }>;
    receiveMetadata(key: string, value: any): void;
    receiveSampleRestrictions(restrictions: {
        audioRestricted: boolean;
        videoRestricted: boolean;
    }): void;
    sendDataFrame(key: string, value: any): void;
    receiveData(data: DataAMF0Data | DataAMF3Data): void;
    restrictSampleAccess(audioRestricted: boolean, videoRestricted: boolean): void;
    pause(paused: boolean, milliseconds: number): void;
    seek(milliseconds: number): void;
    publish(streamKey: string, publishType: 'live' | 'record' | 'append'): void;
    play(streamKey: string, start: number, duration: number, reset: boolean): void;
    play2(params: any): void;
    isAudioEnabled: boolean;
    isVideoEnabled: boolean;
    audioEnabled: Subject<boolean>;
    videoEnabled: Subject<boolean>;
    enableAudio(enabled: boolean): void;
    enableVideo(enabled: boolean): void;
    /**
     * Send a video message. Can provide either a VideoMessageData object or an already serialized
     * VideoMessageData object.
     * @param timestamp
     * @param message
     * @returns
     */
    sendVideo(timestamp: number, message: VideoMessageData | Buffer): void;
    /**
     * Send an audio message. Can provide either an AudioMessageData object or an already serialized
     * AudioMessageData object.
     * @param timestamp
     * @param message
     * @returns
     */
    sendAudio(timestamp: number, message: AudioMessageData | Buffer): void;
    /**
     * Handle a custom RPC call. Return true if it was handled, otherwise an error result is sent to the
     * client and an error is printed to the logs.
     *
     * @param commandName
     * @param command
     * @param args
     * @returns
     */
    call(commandName: string, command: any, args: Record<string, any>): boolean;
    /**
     * Receive an audio message on this stream.
     * @param timestamp The timestamp of the audio message
     * @param message The decoded message
     * @param buffer The serialized message for efficient passthrough to other streams
     */
    receiveAudio(timestamp: number, message: AudioMessageData, buffer: Buffer): void;
    /**
     * Receive a video message on this stream.
     * @param timestamp The timestamp of the video message
     * @param message The decoded message
     * @param buffer The serialized message for efficient passthrough to other streams
     */
    receiveVideo(timestamp: number, message: VideoMessageData, buffer: Buffer): void;
    receiveMessage(message: Message): void;
    sendCommand0(commandName: string, parameters: any[], options?: {
        transactionId?: number;
        commandObject?: any;
    }): void;
    receiveCommand(commandName: string, transactionId: number, commandObject: any, parameters: any[]): Promise<void>;
}
export declare class Session {
    readonly server: Server;
    readonly socket: net.Socket;
    constructor(server: Server, socket: net.Socket);
    close(): void;
    chunkSession: ChunkStreamSession;
    private receiveMessage;
    private _streams;
    getStream(id: number): ServerStream;
    private handleStreamMessage;
    dataReceived: Subject<any>;
    receiveData(data: any): void;
    /**
     * Handle a custom RPC call. Return true if it was handled, otherwise an error result is sent to the
     * client and an error is printed to the logs.
     *
     * @param commandName
     * @param command
     * @param args
     * @returns
     */
    call(commandName: string, command: any, args: Record<string, any>): boolean;
    receiveCommand(commandName: string, transactionId: number, commandObject: any, parameters: any[]): Promise<void>;
    private nextStreamID;
    streamCreated: Subject<ServerStream>;
    protected createStream(id: number): ServerMediaStream;
    private onCreateStream;
    private pingInterval;
    private _pingTime;
    get pingTime(): any;
    set pingTime(value: any);
    private startPingTimer;
    clientConnectInfo: ConnectCommandObject;
    private onConnect;
    messageReceived: Subject<Message>;
    userControl(data: UserControlData): void;
    ping(): void;
    streamBegin(streamID: number): void;
    streamEnd(streamID: number): void;
    streamDry(streamID: number): void;
    sendCommand0(commandName: string, parameters: any[], options?: {
        messageStreamId?: number;
        transactionId?: number;
        commandObject?: any;
    }): void;
    sendData0(data: DataAMF0Data, options?: {
        messageStreamId?: number;
    }): void;
    sendCommand3(commandName: string, parameters: any[], options?: {
        transactionId?: number;
        commandObject?: any;
    }): void;
    /**
     * Prepare the server for receiving a media stream, if necessary.
     * The default implementation does nothing.
     * @param streamName
     * @returns
     */
    protected FCPublish(streamName: string): string;
    /**
     * Prepare the server for no longer receiving a media stream, if necessary.
     * The default implementation does nothing.
     * @param streamName
     */
    protected FCUnpublish(streamName: string): void;
    /**
     * Subscribe the server to a specific upstream media stream, if necessary.
     * Traditionally this is used to tell an edge server to start pulling a stream from the
     * appropriate origin. That logic is specific to a particular RTMP server implementation,
     * so by default this method does nothing.
     * @param streamName
     * @param mediaCasterType
     */
    protected FCSubscribe(streamName: string, mediaCasterType?: string): void;
    /**
     * Unsubscribe the server from a specific upstream media stream, if necessary.
     * The implementation should properly handle multiple subscribed streams in deciding
     * how to handle this operation, since this call is specific only to a single client.
     * Since this logic is specific to a particular RTMP server implementation,
     * by default this method does nothing.
     * @param streamName
     */
    protected FCUnsubscribe(streamName: string): void;
    /**
     * A variant method name of FCUnsubscribe. The default implementation calls FCUnsubscribe().
     * You should implement FCUnsubscribe() instead if you require this functionality.
     * @param streamName
     */
    protected FCUnSubscribe(streamName: string): void;
}
export declare class Server {
    readonly port: number;
    constructor(port?: number);
    version: number;
    fullVersion: string;
    private _server;
    connections: Session[];
    preferredWindowSize: number;
    preferredChunkSize: number;
    preferredPingTime: number;
    protected createSession(socket: net.Socket): Session;
    listen(): Promise<void>;
    stop(): void;
}