import { AgoraRteAudioSourceType, AgoraRteMediaPublishState, AgoraRteMediaSourceState, AgoraRteRegion, AgoraRteVideoSourceType } from '../../type';
import { AgoraRestfulClient } from './client';
import { AgoraRteOperatCause } from '../processor/type';
import { AgoraRteEntryRoomResponse } from '../scene/type';
import { AgoraRteUploadEvent } from '../monitor/type';
export interface EntryRequestStreamParams {
    videoSourceUuid?: string;
    audioSourceUuid?: string;
    streamName?: string;
    audioState: AgoraRteMediaPublishState;
    videoState: AgoraRteMediaPublishState;
    videoSourceType: AgoraRteVideoSourceType;
    audioSourceType: AgoraRteAudioSourceType;
    audioSourceState?: AgoraRteMediaSourceState;
    videoSourceState?: AgoraRteMediaSourceState;
}
export interface EntryRequestParams {
    userId: string;
    roomId: string;
    userName: string;
    role: string;
    userProperties?: Record<string, unknown>;
    platform?: number;
    streamUuid?: string;
    streams?: EntryRequestStreamParams[];
}
export type AgoraRteSyncSequenceResponse = {
    total: number;
    nextId: number;
    list: {
        sequence: number;
        cmd: number;
        version: number;
        data: unknown;
    }[];
};
export declare class AgoraRteServiceApi {
    private _client;
    private _appId;
    private _region;
    private _pathIncludeRegion;
    protected logger: import("agora-foundation/lib/logger/type").Logger;
    private _pathPrefix;
    constructor(_client: AgoraRestfulClient, _appId: string, _region: AgoraRteRegion, _pathIncludeRegion?: boolean);
    setRestfulClient(client: AgoraRestfulClient): void;
    cloneWithUserAndRoomCredential(userId: string, userToken: string, roomToken: string): AgoraRteServiceApi;
    createRoom(params: {
        roomUuid: string;
        roomName: string;
        roleConfig?: unknown;
        roomProperties?: unknown;
        memberLimit?: number;
    }): Promise<AgoraRteEntryRoomResponse>;
    entryRoom(params: EntryRequestParams): Promise<AgoraRteEntryRoomResponse>;
    syncChannelSequence({ roomUuid, seqId, count, }: {
        roomUuid: string;
        seqId: number;
        count: number;
    }): Promise<AgoraRteSyncSequenceResponse>;
    syncPeerSequence({ roomUuid, userUuid, seqId, count, }: {
        roomUuid: string;
        userUuid: string;
        seqId: number;
        count: number;
    }): Promise<AgoraRteSyncSequenceResponse>;
    updateRoomProperties({ roomUuid, properties, cause, }: {
        roomUuid: string;
        properties: unknown;
        cause?: unknown;
    }): Promise<any>;
    deleteRoomProperties({ roomUuid, properties, cause, }: {
        roomUuid: string;
        properties: string[];
        cause?: unknown;
    }): Promise<any>;
    updateUserProperties({ roomUuid, userUuid, properties, cause, }: {
        roomUuid: string;
        userUuid: string;
        properties: unknown;
        cause?: unknown;
    }): Promise<any>;
    updateBatchUserProperties({ roomUuid, data, }: {
        data: {
            userUuid: string;
            properties: unknown;
            cause?: unknown;
        }[];
        roomUuid: string;
    }): Promise<any>;
    deleteUserProperties({ roomUuid, userUuid, properties, cause, }: {
        roomUuid: string;
        userUuid: string;
        properties: string[];
        cause?: unknown;
    }): Promise<any>;
    deleteBatchUserProperties({ roomUuid, data, }: {
        roomUuid: string;
        data: {
            properties: string[];
            userUuid: string;
            cause?: unknown;
        }[];
    }): Promise<any>;
    upsertStream({ roomUuid, userUuid, streamUuid, streamName, videoState, audioState, videoSourceType, audioSourceType, converterOptions, }: {
        roomUuid: string;
        userUuid: string;
        streamUuid: string;
        streamName?: string;
        videoSourceType?: AgoraRteVideoSourceType;
        audioSourceType?: AgoraRteAudioSourceType;
        videoState?: AgoraRteMediaPublishState;
        audioState?: AgoraRteMediaPublishState;
        converterOptions?: {
            width: number;
            height: number;
            bitrate: number;
            seiOptions?: {
                source?: {
                    metadata?: boolean;
                    datastream?: boolean;
                    customized?: unknown;
                };
                sink?: {
                    type?: number;
                };
            };
        };
    }): Promise<any>;
    createStreamBatch({ roomUuid, streams, cause, }: {
        roomUuid: string;
        streams: {
            streamName?: string;
            userUuid?: string;
            streamUuid?: string;
            videoState?: AgoraRteMediaPublishState;
            audioState?: AgoraRteMediaPublishState;
            videoSourceType?: AgoraRteVideoSourceType;
            audioSourceType?: AgoraRteAudioSourceType;
            videoSourceUuid?: string;
            audioSourceUuid?: string;
        }[];
        cause?: AgoraRteOperatCause;
    }): Promise<any>;
    updateStreamBatch({ roomUuid, streams, cause, }: {
        roomUuid: string;
        streams: {
            streamName?: string;
            userUuid?: string;
            streamUuid?: string;
            videoState?: AgoraRteMediaPublishState;
            audioState?: AgoraRteMediaPublishState;
            videoSourceType?: AgoraRteVideoSourceType;
            audioSourceType?: AgoraRteAudioSourceType;
            videoSourceUuid?: string;
            audioSourceUuid?: string;
        }[];
        cause?: AgoraRteOperatCause;
    }): Promise<any>;
    updateStreamBatchByCondition({ roomUuid, videoState, audioState, includeRoles, excludeRoles, condition, cause, }: {
        roomUuid: string;
        videoState?: number;
        audioState?: number;
        includeRoles?: string[];
        excludeRoles?: string[];
        condition?: {
            videoSourceType?: number;
            audioSourceType?: number;
        };
        cause?: AgoraRteOperatCause;
    }): Promise<any>;
    deleteStream(roomUuid: string, userUuid: string, streamUuid: string): Promise<any>;
    deleteStreamBatch(roomUuid: string, streams: {
        streamUuid: string;
    }[], cause?: AgoraRteOperatCause): Promise<any>;
    updateStream({ roomUuid, userUuid, streamUuid, videoSourceState, audioSourceState, videoSourceUuid, audioSourceUuid, }: {
        roomUuid: string;
        userUuid: string;
        streamUuid: string;
        videoSourceState?: AgoraRteMediaSourceState;
        audioSourceState?: AgoraRteMediaSourceState;
        videoSourceUuid?: string;
        audioSourceUuid?: string;
    }): Promise<any>;
    updateStreamWithToken({ roomUuid, userUuid, streamUuid, videoSourceState, audioSourceState, videoSourceUuid, audioSourceUuid, }: {
        roomUuid: string;
        userUuid: string;
        streamUuid: string;
        videoSourceState?: AgoraRteMediaSourceState;
        audioSourceState?: AgoraRteMediaSourceState;
        videoSourceUuid?: string;
        audioSourceUuid?: string;
    }, userToken: string, roomToken: string): Promise<any>;
    updateStreamLayers({ roomUuid, userUuid, layers, }: {
        roomUuid: string;
        userUuid: string;
        layers: {
            subTs: number;
            subStreamLayer: Record<string, number>;
        };
    }): Promise<any>;
    sendRoomChatMessage({ roomUuid, message }: {
        message: string;
        roomUuid: string;
    }): Promise<any>;
    sendCustomChannelMessage({ roomUuid, payload, cmd, sync, }: {
        roomUuid: string;
        payload: Record<string, unknown>;
        sync?: boolean;
        cmd: string;
    }): Promise<any>;
    sendCustomPeerMessage({ payload, toUserUuid, waitForAck, }: {
        payload: {
            cmd: string;
            data: unknown;
        };
        toUserUuid: string;
        waitForAck?: boolean;
    }): Promise<any>;
    updateOnlineState({ userUuid, roomUuid }: {
        roomUuid: string;
        userUuid: string;
    }): Promise<any>;
    fetchUserList({ userRole, pageIndex, pageSize, roomId, }: {
        userRole?: string;
        pageSize?: number;
        pageIndex?: number;
        roomId: string;
    }): Promise<any>;
    uploadEvent({ userId, event }: {
        userId: string;
        event: AgoraRteUploadEvent;
    }): Promise<any>;
}