livekit-client/dist/src/room/data-track/outgoing/errors.d.ts

JavaScript/TypeScript client SDK for LiveKit

import { LivekitReasonedError } from '../../errors';
import { DataTrackPacketizerError } from '../packetizer';
export declare enum DataTrackPublishErrorReason {
    /**
     * Local participant does not have permission to publish data tracks.
     *
     * Ensure the participant's token contains the `canPublishData` grant.
     */
    NotAllowed = 0,
    /** A track with the same name is already published by the local participant. */
    DuplicateName = 1,
    /** Request to publish the track took long to complete. */
    Timeout = 2,
    /** No additional data tracks can be published by the local participant. */
    LimitReached = 3,
    /** Cannot publish data track when the room is disconnected. */
    Disconnected = 4,
    Cancelled = 5,
    /** The name requested is not able to be used when creating the data track. */
    InvalidName = 6,
    /** There was an error publishing, but it was not something that could be sorted into a known
     * category. */
    Unknown = 7
}
export declare class DataTrackPublishError<Reason extends DataTrackPublishErrorReason = DataTrackPublishErrorReason> extends LivekitReasonedError<Reason> {
    readonly name = "DataTrackPublishError";
    reason: Reason;
    reasonName: string;
    /** Underling message from the SFU, if one was provided */
    rawMessage?: string;
    constructor(message: string, reason: Reason, options?: {
        rawMessage?: string;
        cause?: unknown;
    });
    static notAllowed(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.NotAllowed>;
    static duplicateName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.DuplicateName>;
    static invalidName(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.InvalidName>;
    static timeout(): DataTrackPublishError<DataTrackPublishErrorReason.Timeout>;
    static limitReached(rawMessage?: string): DataTrackPublishError<DataTrackPublishErrorReason.LimitReached>;
    static unknown(reason: number, message: string): DataTrackPublishError<DataTrackPublishErrorReason.Unknown>;
    static disconnected(): DataTrackPublishError<DataTrackPublishErrorReason.Disconnected>;
    static cancelled(): DataTrackPublishError<DataTrackPublishErrorReason.Cancelled>;
}
export declare enum DataTrackPushFrameErrorReason {
    /** Track is no longer published. */
    TrackUnpublished = 0,
    /** Frame was dropped. */
    Dropped = 1
}
export declare class DataTrackPushFrameError<Reason extends DataTrackPushFrameErrorReason = DataTrackPushFrameErrorReason> extends LivekitReasonedError<Reason> {
    readonly name = "DataTrackPushFrameError";
    reason: Reason;
    reasonName: string;
    constructor(message: string, reason: Reason, options?: {
        cause?: unknown;
    });
    static trackUnpublished(): DataTrackPushFrameError<DataTrackPushFrameErrorReason.TrackUnpublished>;
    static dropped(cause?: unknown): DataTrackPushFrameError<DataTrackPushFrameErrorReason.Dropped>;
}
export declare enum DataTrackOutgoingPipelineErrorReason {
    Packetizer = 0,
    Encryption = 1
}
export declare class DataTrackOutgoingPipelineError<Reason extends DataTrackOutgoingPipelineErrorReason = DataTrackOutgoingPipelineErrorReason> extends LivekitReasonedError<Reason> {
    readonly name = "DataTrackOutgoingPipelineError";
    reason: Reason;
    reasonName: string;
    constructor(message: string, reason: Reason, options?: {
        cause?: unknown;
    });
    static packetizer(cause: DataTrackPacketizerError): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Packetizer>;
    static encryption(cause: unknown): DataTrackOutgoingPipelineError<DataTrackOutgoingPipelineErrorReason.Encryption>;
}
//# sourceMappingURL=errors.d.ts.map