@gala-chain/launchpad-sdk 5.0.3 → 5.0.4-beta.1

package/dist/src/types/streaming.dto.d.ts

@@ -0,0 +1,1141 @@
+/**
+ * Streaming API Data Transfer Objects and Types
+ *
+ * This module defines all types and interfaces for live streaming operations including
+ * stream management, recordings, simulcast targets, and WebSocket events.
+ *
+ * @since 5.1.0
+ */
+import { PaginationParams, AddressFormat, InternalApiResponse } from './common';
+/**
+ * Stream status enumeration
+ *
+ * Represents the current state of a live stream:
+ * - IDLE: Stream exists but is not currently broadcasting
+ * - ACTIVE: Stream is currently live and broadcasting
+ * - DISABLED: Stream has been disabled by admin
+ */
+export declare const STREAM_STATUS: {
+    readonly IDLE: "IDLE";
+    readonly ACTIVE: "ACTIVE";
+    readonly DISABLED: "DISABLED";
+};
+export type StreamStatus = (typeof STREAM_STATUS)[keyof typeof STREAM_STATUS];
+/**
+ * Stream information returned from GET /live/:tokenName
+ */
+export interface StreamInfo {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /** Current stream status */
+    status: StreamStatus;
+    /** Stream key for broadcasting (only available to stream owner) */
+    streamKey?: string;
+    /** Playback ID for viewers (available when stream is active) */
+    playbackId: string | null;
+    /** Whether the stream is currently live */
+    isLive: boolean;
+    /** Stream title */
+    title?: string;
+    /** Stream description */
+    description?: string;
+    /** Creator wallet address */
+    creatorAddress: AddressFormat;
+    /** Stream creation timestamp (ISO 8601) */
+    createdAt: string;
+    /** Last update timestamp (ISO 8601) */
+    updatedAt: string;
+    /** Current viewer count */
+    viewerCount?: number;
+    /** Whether streaming is enabled for this token */
+    enabled: boolean;
+    /**
+     * Video aspect ratio (e.g., "16:9", "9:16")
+     * Captured from Mux when stream goes active
+     * @since 5.5.0
+     */
+    aspectRatio?: string;
+    /**
+     * Next scheduled live stream time (ISO 8601 string) or null if not set
+     * Consolidated from /stream/settings endpoint
+     * @since 5.7.0
+     */
+    nextLiveStreamAt?: string | null;
+    /**
+     * Stream language (ISO 639-1 code, e.g., "en", "es", "ja")
+     * Consolidated from /stream/settings endpoint
+     * Note: Field name is 'language' to match backend (not 'streamLanguage')
+     * @since 5.7.0
+     */
+    language?: string;
+}
+/**
+ * Response from POST /live/:tokenName/start
+ */
+export interface StartStreamResult {
+    /** Token name */
+    tokenName: string;
+    /** Stream key for RTMP broadcast */
+    streamKey: string;
+    /** RTMP ingest URL */
+    rtmpUrl: string;
+    /** Playback ID for HLS playback */
+    playbackId: string;
+    /** HLS playback URL */
+    playbackUrl: string;
+    /** Stream status (should be IDLE initially) */
+    status: StreamStatus;
+    /** Stream creation timestamp (ISO 8601) */
+    createdAt: string;
+}
+/**
+ * Response from POST /live/:tokenName/reset-key
+ */
+export interface ResetStreamKeyResult {
+    /** Token name */
+    tokenName: string;
+    /** New stream key */
+    streamKey: string;
+    /** RTMP ingest URL (unchanged) */
+    rtmpUrl: string;
+    /** Stream key reset timestamp (ISO 8601) */
+    resetAt: string;
+}
+/**
+ * Recording status enumeration
+ */
+export declare const RECORDING_STATUS: {
+    readonly READY: "READY";
+    readonly PROCESSING: "PROCESSING";
+    readonly ERRORED: "ERRORED";
+    readonly DELETED: "DELETED";
+};
+export type RecordingStatus = (typeof RECORDING_STATUS)[keyof typeof RECORDING_STATUS];
+/**
+ * Stream recording information
+ */
+export interface StreamRecording {
+    /** Unique recording asset ID (Mux asset ID) */
+    assetId: string;
+    /** Token name this recording belongs to */
+    tokenName: string;
+    /** Recording status */
+    status: RecordingStatus;
+    /** Recording duration in seconds */
+    duration: number;
+    /** Recording creation timestamp (ISO 8601) */
+    createdAt: string;
+    /** Recording thumbnail URL */
+    thumbnailUrl?: string;
+    /** Whether the recording is downloadable */
+    downloadable: boolean;
+    /** File size in bytes (when available) */
+    fileSize?: number;
+    /**
+     * Video aspect ratio (e.g., "16:9", "9:16")
+     * @since 5.5.0
+     */
+    aspectRatio?: string;
+}
+/**
+ * Options for fetching recordings
+ */
+export interface FetchRecordingsOptions extends Partial<PaginationParams> {
+    /** Token name to fetch recordings for */
+    tokenName: string;
+}
+/**
+ * Result from GET /live/:tokenName/recordings
+ */
+export interface RecordingsResult {
+    /** Array of recordings */
+    recordings: StreamRecording[];
+    /** Token name */
+    tokenName: string;
+    /** Current page number */
+    page: number;
+    /** Items per page */
+    limit: number;
+    /** Total number of recordings */
+    total: number;
+    /** Whether there are more pages */
+    hasNext: boolean;
+}
+/**
+ * Result from GET /live/:tokenName/recordings/:assetId/download
+ */
+export interface RecordingDownloadResult {
+    /** Current status of master file preparation */
+    status: 'none' | 'preparing' | 'ready' | 'errored';
+    /** Download URL (only present when status is 'ready') */
+    url?: string;
+}
+/**
+ * Simulcast target status
+ */
+export declare const SIMULCAST_STATUS: {
+    readonly ACTIVE: "ACTIVE";
+    readonly IDLE: "IDLE";
+    readonly ERRORED: "ERRORED";
+    readonly DISABLED: "DISABLED";
+};
+export type SimulcastStatus = (typeof SIMULCAST_STATUS)[keyof typeof SIMULCAST_STATUS];
+/**
+ * Simulcast platform type
+ */
+export declare const SIMULCAST_PLATFORM: {
+    readonly YOUTUBE: "YOUTUBE";
+    readonly TWITCH: "TWITCH";
+    readonly FACEBOOK: "FACEBOOK";
+    readonly CUSTOM: "CUSTOM";
+};
+export type SimulcastPlatform = (typeof SIMULCAST_PLATFORM)[keyof typeof SIMULCAST_PLATFORM];
+/**
+ * Simulcast target information
+ */
+export interface SimulcastTarget {
+    /** Unique target ID */
+    targetId: string;
+    /** Platform type */
+    platform: SimulcastPlatform;
+    /** RTMP URL for the target */
+    rtmpUrl: string;
+    /** Stream key for the target (masked in responses) */
+    streamKey?: string;
+    /** Target status */
+    status: SimulcastStatus;
+    /** Optional display name for the target */
+    name?: string;
+    /** Target creation timestamp (ISO 8601) */
+    createdAt: string;
+    /** Last error message if status is ERRORED */
+    errorMessage?: string;
+}
+/**
+ * Options for adding a simulcast target
+ */
+export interface AddSimulcastTargetOptions {
+    /** Token name */
+    tokenName: string;
+    /** Platform type */
+    platform: SimulcastPlatform;
+    /** RTMP URL for the target */
+    rtmpUrl: string;
+    /** Stream key for the target */
+    streamKey: string;
+    /** Optional display name */
+    name?: string;
+}
+/**
+ * Result from GET /live/:tokenName/simulcast
+ */
+export interface SimulcastTargetsResult {
+    /** Array of simulcast targets */
+    targets: SimulcastTarget[];
+    /** Token name */
+    tokenName: string;
+    /** Maximum allowed targets */
+    maxTargets: number;
+}
+/**
+ * Result from POST /live/:tokenName/simulcast
+ */
+export interface AddSimulcastTargetResult {
+    /** Created target information */
+    target: SimulcastTarget;
+    /** Token name */
+    tokenName: string;
+}
+/**
+ * Global streaming status response
+ */
+export interface GlobalStreamingStatus {
+    /** Whether streaming is globally enabled */
+    enabled: boolean;
+    /** Last status change timestamp (ISO 8601) */
+    updatedAt?: string;
+    /** Admin who changed the status (if available) */
+    updatedBy?: string;
+}
+/**
+ * WebSocket event: stream_status
+ *
+ * Emitted when stream status changes (goes live, ends, or status changes).
+ * This is the PRIMARY event for real-time stream state updates.
+ *
+ * @since 5.1.0 - Added based on backend review (HIGH PRIORITY)
+ */
+export interface StreamStatusEvent {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /** Current stream status */
+    status: StreamStatus;
+    /** Playback ID (null when not active) */
+    playbackId: string | null;
+    /** Whether stream is currently live */
+    isLive: boolean;
+    /**
+     * Video aspect ratio (e.g., "16:9", "9:16")
+     * Only present when stream becomes ACTIVE, cleared when IDLE
+     * @since 5.5.0
+     */
+    aspectRatio?: string;
+}
+/**
+ * WebSocket event: stream_subscribed
+ *
+ * Emitted when client successfully subscribes to a stream room
+ */
+export interface StreamSubscribedEvent {
+    /** Socket.IO room name (format: stream:{tokenName}) */
+    room: string;
+    /** Token name (lowercase) */
+    tokenName: string;
+}
+/**
+ * WebSocket event: stream_unsubscribed
+ *
+ * Emitted when client leaves a stream room
+ */
+export interface StreamUnsubscribedEvent {
+    /** Socket.IO room name */
+    room: string;
+}
+/**
+ * WebSocket event: viewer_count
+ *
+ * Emitted automatically when viewer count changes.
+ * Note: Auto-emits on subscribe/unsubscribe without explicit request.
+ *
+ * @since 5.1.0 - Documented auto-emit behavior from backend review
+ */
+export interface ViewerCountEvent {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /** Current viewer count */
+    viewerCount: number;
+}
+/**
+ * WebSocket event: stream_global_status
+ *
+ * Emitted when global streaming status changes
+ */
+export interface StreamGlobalStatusEvent {
+    /** Whether streaming is globally enabled */
+    enabled: boolean;
+    /** Timestamp of change (ISO 8601) */
+    updatedAt: string;
+}
+/**
+ * Standard backend response wrapper for streaming endpoints
+ * @internal
+ * @see InternalApiResponse in common.ts for the shared type
+ * @deprecated Use InternalApiResponse from common.ts directly
+ */
+export type InternalStreamingResponse<T = unknown> = InternalApiResponse<T>;
+/**
+ * Internal response from stream info endpoint
+ * @internal
+ */
+export interface InternalGetStreamInfoResponse extends InternalStreamingResponse<StreamInfo> {
+}
+/**
+ * Internal response from start stream endpoint
+ * @internal
+ */
+export interface InternalStartStreamResponse extends InternalStreamingResponse<StartStreamResult> {
+}
+/**
+ * Internal response from reset stream key endpoint
+ * @internal
+ */
+export interface InternalResetStreamKeyResponse extends InternalStreamingResponse<ResetStreamKeyResult> {
+}
+/**
+ * Internal response from recordings endpoint
+ * @internal
+ */
+export interface InternalGetRecordingsResponse extends InternalStreamingResponse<{
+    recordings: StreamRecording[];
+    total: number;
+    page: number;
+    limit: number;
+}> {
+}
+/**
+ * Internal response from recording download endpoint
+ * @internal
+ */
+export interface InternalGetRecordingDownloadResponse extends InternalStreamingResponse<RecordingDownloadResult> {
+}
+/**
+ * Internal response from simulcast targets endpoint
+ * @internal
+ */
+export interface InternalGetSimulcastTargetsResponse extends InternalStreamingResponse<SimulcastTargetsResult> {
+}
+/**
+ * Internal response from add simulcast target endpoint
+ * @internal
+ */
+export interface InternalAddSimulcastTargetResponse extends InternalStreamingResponse<AddSimulcastTargetResult> {
+}
+/**
+ * Internal response from global streaming status endpoint
+ * @internal
+ */
+export interface InternalGlobalStreamingStatusResponse extends InternalStreamingResponse<GlobalStreamingStatus> {
+}
+/**
+ * Internal response from enable/disable endpoints
+ * @internal
+ */
+export interface InternalStreamingToggleResponse extends InternalStreamingResponse<{
+    enabled: boolean;
+    tokenName?: string;
+}> {
+}
+/** Type guard for StreamStatus */
+export declare const isStreamStatus: (value: unknown) => value is "IDLE" | "ACTIVE" | "DISABLED";
+/** Type guard for RecordingStatus */
+export declare const isRecordingStatus: (value: unknown) => value is "PROCESSING" | "READY" | "ERRORED" | "DELETED";
+/** Type guard for SimulcastPlatform */
+export declare const isSimulcastPlatform: (value: unknown) => value is "YOUTUBE" | "TWITCH" | "FACEBOOK" | "CUSTOM";
+/**
+ * Type guard for StreamStatusEvent
+ */
+export declare function isStreamStatusEvent(obj: unknown): obj is StreamStatusEvent;
+/**
+ * Type guard for ViewerCountEvent
+ */
+export declare function isViewerCountEvent(obj: unknown): obj is ViewerCountEvent;
+/**
+ * Stream settings for countdown and language features
+ *
+ * Contains the next live stream countdown time and stream language.
+ * Field names aligned with backend stream-settings.dto.ts:
+ * - nextLiveStreamAt: ISO 8601 format or null
+ * - language: ISO 639-1 code (backend uses 'language' not 'streamLanguage')
+ *
+ * @since 5.6.0
+ */
+export interface StreamSettings {
+    /**
+     * Scheduled stream start time (ISO 8601 format)
+     * null when no countdown is set
+     * Backend field: nextLiveStreamAt
+     */
+    nextLiveStreamAt: string | null;
+    /**
+     * Stream language (ISO 639-1 code, e.g., "en", "es", "ja")
+     * Defaults to "en" if not set
+     * Backend field: language (not streamLanguage)
+     */
+    language: string;
+}
+/**
+ * Options for setting the next live stream countdown
+ *
+ * @since 5.6.0
+ */
+export interface SetCountdownOptions {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /**
+     * Next live stream time - accepts Date object, ISO 8601 string, or null to clear
+     * null clears the countdown
+     */
+    nextLiveStreamAt: Date | string | null;
+}
+/**
+ * Options for setting the stream language
+ *
+ * @since 5.6.0
+ */
+export interface SetLanguageOptions {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /**
+     * Stream language (ISO 639-1 code)
+     * Examples: "en", "es", "ja", "zh-CN"
+     */
+    language: string;
+}
+/**
+ * WebSocket event: stream_countdown_updated
+ *
+ * Emitted when the next live stream countdown is set or cleared.
+ * Sent to the stream room when owner or admin updates the countdown.
+ *
+ * @since 5.6.0
+ */
+export interface StreamCountdownEvent {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /**
+     * Scheduled stream start time (ISO 8601 format)
+     * null when countdown is cleared (stream went live or manually cleared)
+     */
+    nextLiveStreamAt: string | null;
+}
+/**
+ * WebSocket event: stream_language_updated
+ *
+ * Emitted when the stream language is changed.
+ * Sent to the stream room when owner or admin updates the language.
+ *
+ * @since 5.6.0
+ */
+export interface StreamLanguageEvent {
+    /** Token name (lowercase) */
+    tokenName: string;
+    /**
+     * Updated stream language (ISO 639-1 code)
+     */
+    language: string;
+}
+/**
+ * Internal response from stream settings endpoint
+ * @internal
+ * @since 5.6.0
+ */
+export interface InternalStreamSettingsResponse extends InternalStreamingResponse<StreamSettings> {
+}
+/**
+ * Type guard for StreamCountdownEvent
+ * @since 5.6.0
+ */
+export declare function isStreamCountdownEvent(obj: unknown): obj is StreamCountdownEvent;
+/**
+ * Type guard for StreamLanguageEvent
+ * @since 5.6.0
+ */
+export declare function isStreamLanguageEvent(obj: unknown): obj is StreamLanguageEvent;
+/**
+ * ISO 639-1 language code validation
+ * Validates language codes like "en", "es", "zh-CN"
+ * @since 5.6.0
+ */
+export declare function isValidLanguageCode(code: unknown): code is string;
+/**
+ * Stream role enumeration
+ *
+ * Represents the user's access level to a token's stream:
+ * - OWNER: Token creator, full access to everything
+ * - MANAGER: Full management access (stream controls + recordings + settings + moderation)
+ * - TECHNICAL_PRODUCER: Stream operations (controls + recordings + simulcast, NO moderation)
+ * - MODERATOR: Chat moderation only (ban/unban, message deletion)
+ *
+ * @since 5.7.0
+ */
+export declare const STREAM_ROLE: {
+    readonly OWNER: "OWNER";
+    readonly MANAGER: "MANAGER";
+    readonly TECHNICAL_PRODUCER: "TECHNICAL_PRODUCER";
+    readonly MODERATOR: "MODERATOR";
+};
+export type StreamRole = (typeof STREAM_ROLE)[keyof typeof STREAM_ROLE];
+/**
+ * Source of the user's role access
+ *
+ * - OWNER: User is the token creator
+ * - MODERATOR: User claimed a moderator invite
+ *
+ * @since 5.7.0
+ */
+export declare const ROLE_SOURCE: {
+    readonly OWNER: "OWNER";
+    readonly MODERATOR: "MODERATOR";
+};
+export type RoleSource = (typeof ROLE_SOURCE)[keyof typeof ROLE_SOURCE];
+/**
+ * Invite scope for moderator access
+ *
+ * - TOKEN: Access to a specific token only
+ * - ALL_OWNER_TOKENS: Blanket access to all tokens by the inviting owner
+ *
+ * @since 5.7.0
+ */
+export type InviteScope = 'TOKEN' | 'ALL_OWNER_TOKENS';
+/**
+ * Options for getting stream role
+ *
+ * @since 5.7.0
+ */
+export interface GetStreamRoleOptions {
+    /**
+     * Token name to check role for
+     * @example "mycoin"
+     */
+    tokenName: string;
+}
+/**
+ * Stream role response from GET /live/:tokenName/role
+ *
+ * Returns the authenticated user's effective role for a token's stream.
+ * Used by frontend Studio page to detect permissions.
+ *
+ * @since 5.7.0
+ */
+export interface StreamRoleResponse {
+    /**
+     * User's effective role for this token's stream
+     * null if user has no access
+     */
+    role: StreamRole | null;
+    /**
+     * Whether the user is the token owner
+     */
+    isOwner: boolean;
+    /**
+     * Source of access: 'OWNER' (token creator), 'MODERATOR' (claimed invite), or null
+     */
+    source: RoleSource | null;
+    /**
+     * For moderator access: the scope of the invite
+     * Only present when source is 'MODERATOR'
+     */
+    inviteScope?: InviteScope | null;
+}
+/**
+ * Internal response from stream role endpoint
+ * @internal
+ * @since 5.7.0
+ */
+export interface InternalStreamRoleResponse extends InternalStreamingResponse<StreamRoleResponse> {
+}
+/**
+ * Type guard for StreamRole
+ * @since 5.7.0
+ */
+export declare const isStreamRole: (value: unknown) => value is "MANAGER" | "TECHNICAL_PRODUCER" | "MODERATOR" | "OWNER";
+/**
+ * Type guard for RoleSource
+ * @since 5.7.0
+ */
+export declare const isRoleSource: (value: unknown) => value is "MODERATOR" | "OWNER";
+/**
+ * Type guard for StreamRoleResponse
+ * @since 5.7.0
+ */
+export declare function isStreamRoleResponse(obj: unknown): obj is StreamRoleResponse;
+/**
+ * Stream permission enumeration
+ *
+ * All permissions available in the role system:
+ * - MANAGE_COMMENTS: Create/delete comments
+ * - MANAGE_CHAT: Send/delete chat messages
+ * - BAN_USERS: Ban users from token streams
+ * - UNBAN_USERS: Remove bans from users
+ * - MANAGE_SIMULCAST: Add/remove simulcast targets
+ * - GET_STREAM_KEY: View the stream key
+ * - STOP_STREAM: Stop an active stream
+ * - RESET_STREAM_KEY: Generate a new stream key
+ * - START_STREAM: Start a new stream
+ * - DELETE_RECORDINGS: Delete stream recordings
+ * - MANAGE_STREAM_SETTINGS: Update stream settings (countdown, language)
+ *
+ * @since 5.10.0
+ */
+export declare const STREAM_PERMISSION: {
+    readonly MANAGE_COMMENTS: "MANAGE_COMMENTS";
+    readonly MANAGE_CHAT: "MANAGE_CHAT";
+    readonly BAN_USERS: "BAN_USERS";
+    readonly UNBAN_USERS: "UNBAN_USERS";
+    readonly MANAGE_SIMULCAST: "MANAGE_SIMULCAST";
+    readonly GET_STREAM_KEY: "GET_STREAM_KEY";
+    readonly STOP_STREAM: "STOP_STREAM";
+    readonly RESET_STREAM_KEY: "RESET_STREAM_KEY";
+    readonly START_STREAM: "START_STREAM";
+    readonly DELETE_RECORDINGS: "DELETE_RECORDINGS";
+    readonly MANAGE_STREAM_SETTINGS: "MANAGE_STREAM_SETTINGS";
+};
+export type StreamPermission = (typeof STREAM_PERMISSION)[keyof typeof STREAM_PERMISSION];
+/**
+ * Information about a single role
+ *
+ * @since 5.10.0
+ */
+export interface RoleInfo {
+    /**
+     * Role name identifier
+     * @example 'MANAGER'
+     */
+    name: StreamRole;
+    /**
+     * Human-readable description of the role
+     * @example 'Full moderator + technical producer + recordings management'
+     */
+    description: string;
+    /**
+     * Hierarchy level (higher = more privileges)
+     * MODERATOR=0, TECHNICAL_PRODUCER=1, MANAGER=2, OWNER=3
+     */
+    level: number;
+    /**
+     * List of permissions this role has
+     */
+    permissions: StreamPermission[];
+}
+/**
+ * Response from GET /live/roles
+ *
+ * Returns all available roles and permissions for token delegation.
+ * This is reference data - it doesn't change per user or token.
+ *
+ * @since 5.10.0
+ */
+export interface AvailableRolesResponse {
+    /**
+     * List of all available roles with their details
+     * Ordered by hierarchy level (highest first): OWNER, MANAGER, TECHNICAL_PRODUCER, MODERATOR
+     */
+    roles: RoleInfo[];
+    /**
+     * List of all available permission names
+     */
+    permissions: StreamPermission[];
+}
+/**
+ * Internal response from available roles endpoint
+ * @internal
+ * @since 5.10.0
+ */
+export interface InternalAvailableRolesResponse extends InternalStreamingResponse<AvailableRolesResponse> {
+}
+/**
+ * Type guard for StreamPermission
+ * @since 5.10.0
+ */
+export declare function isStreamPermission(value: unknown): value is StreamPermission;
+/**
+ * Type guard for RoleInfo
+ * @since 5.10.0
+ */
+export declare function isRoleInfo(obj: unknown): obj is RoleInfo;
+/**
+ * Type guard for AvailableRolesResponse
+ * @since 5.10.0
+ */
+export declare function isAvailableRolesResponse(obj: unknown): obj is AvailableRolesResponse;
+/**
+ * Extended role type for token access check
+ *
+ * Includes all StreamRole values plus 'OVERSEER' for platform-wide access:
+ * - OWNER: Token creator, full access
+ * - MANAGER: Full management via moderator invite
+ * - TECHNICAL_PRODUCER: Stream operations via invite
+ * - MODERATOR: Chat moderation via invite
+ * - OVERSEER: Platform-wide access (Gala employees)
+ *
+ * @since 5.11.0
+ */
+export declare const EXTENDED_STREAM_ROLE: {
+    readonly OVERSEER: "OVERSEER";
+    readonly OWNER: "OWNER";
+    readonly MANAGER: "MANAGER";
+    readonly TECHNICAL_PRODUCER: "TECHNICAL_PRODUCER";
+    readonly MODERATOR: "MODERATOR";
+};
+export type ExtendedStreamRole = (typeof EXTENDED_STREAM_ROLE)[keyof typeof EXTENDED_STREAM_ROLE];
+/**
+ * Source of the user's access to a token
+ *
+ * - ownership: User is the token creator (OWNER role)
+ * - moderator_invite: User claimed a moderator invite (MANAGER/TECH_PRODUCER/MODERATOR)
+ * - overseer: User has platform-wide overseer access
+ *
+ * @since 5.11.0
+ */
+export declare const ACCESS_SOURCE: {
+    readonly OWNERSHIP: "ownership";
+    readonly MODERATOR_INVITE: "moderator_invite";
+    readonly OVERSEER: "overseer";
+};
+export type AccessSource = (typeof ACCESS_SOURCE)[keyof typeof ACCESS_SOURCE];
+/**
+ * Permission flags for token access
+ *
+ * Detailed breakdown of what actions the user can perform.
+ * Permissions vary based on role:
+ * - OWNER/OVERSEER: All permissions
+ * - MANAGER: All permissions (equivalent to owner for operations)
+ * - TECHNICAL_PRODUCER: Stream ops, recordings, simulcast (no moderation)
+ * - MODERATOR: Moderation only (comments, chat, bans)
+ *
+ * @since 5.11.0
+ */
+export interface TokenAccessPermissions {
+    /** Can start/stop streams (OWNER, MANAGER, TECHNICAL_PRODUCER) */
+    canStream: boolean;
+    /** Can moderate (OWNER, MANAGER, MODERATOR) */
+    canModerate: boolean;
+    /** Can manage team invites (OWNER only, not moderators) */
+    canManageTeam: boolean;
+    /** Can view/download recordings (OWNER, MANAGER, TECHNICAL_PRODUCER) */
+    canViewRecordings: boolean;
+    /** Can manage simulcast targets (OWNER, MANAGER, TECHNICAL_PRODUCER) */
+    canSimulcast: boolean;
+    /** Can view analytics/engagement stats (OWNER, MANAGER) */
+    canViewAnalytics: boolean;
+}
+/**
+ * Options for checking token access
+ *
+ * @since 5.11.0
+ */
+export interface GetTokenAccessOptions {
+    /**
+     * Token name to check access for
+     * @example "mycoin"
+     */
+    tokenName: string;
+}
+/**
+ * Token access response from GET /live/:tokenName/access
+ *
+ * Comprehensive access check that combines:
+ * 1. Token ownership check
+ * 2. Moderator invite check
+ * 3. Overseer status check
+ *
+ * Used by frontend to determine if user can access Studio and what they can do.
+ *
+ * @since 5.11.0
+ */
+export interface TokenAccessResult {
+    /**
+     * Whether the user has any access to this token's studio
+     * If false, all other fields are null/false
+     */
+    hasAccess: boolean;
+    /**
+     * User's effective role for this token
+     * null if user has no access
+     */
+    role: ExtendedStreamRole | null;
+    /**
+     * Detailed permission breakdown
+     */
+    permissions: TokenAccessPermissions;
+    /**
+     * How the user got their access
+     * null if user has no access
+     */
+    accessSource: AccessSource | null;
+    /**
+     * For moderator access: the scope of the invite
+     * Only present when accessSource is 'moderator_invite'
+     * - TOKEN: Access to this specific token only
+     * - ALL_OWNER_TOKENS: Access to all tokens by the inviting owner
+     */
+    inviteScope?: InviteScope | null;
+    /**
+     * Whether the user is the token owner
+     * True only when accessSource is 'ownership'
+     */
+    isOwner: boolean;
+    /**
+     * Whether the user has overseer access
+     * True only when accessSource is 'overseer'
+     */
+    isOverseer: boolean;
+}
+/**
+ * Internal backend response for token access endpoint
+ * @internal
+ */
+export interface InternalTokenAccessResponse {
+    status: number;
+    error: boolean;
+    message: string;
+    data?: TokenAccessResult;
+}
+/**
+ * Type guard for TokenAccessPermissions
+ * @since 5.11.0
+ */
+export declare function isTokenAccessPermissions(obj: unknown): obj is TokenAccessPermissions;
+/**
+ * Type guard for ExtendedStreamRole
+ * @since 5.11.0
+ */
+export declare const isExtendedStreamRole: (value: unknown) => value is "MANAGER" | "TECHNICAL_PRODUCER" | "MODERATOR" | "OWNER" | "OVERSEER";
+/**
+ * Type guard for AccessSource
+ * @since 5.11.0
+ */
+export declare const isAccessSource: (value: unknown) => value is "ownership" | "moderator_invite" | "overseer";
+/**
+ * Type guard for TokenAccessResult
+ * @since 5.11.0
+ */
+export declare function isTokenAccessResult(obj: unknown): obj is TokenAccessResult;
+/**
+ * Validates FetchRecordingsOptions
+ *
+ * @param options - Options to validate
+ * @throws {ValidationError} If options are invalid
+ */
+export declare function validateFetchRecordingsOptions(options: FetchRecordingsOptions): void;
+/**
+ * Validates AddSimulcastTargetOptions
+ *
+ * @param options - Options to validate
+ * @throws {ValidationError} If options are invalid
+ */
+export declare function validateAddSimulcastTargetOptions(options: AddSimulcastTargetOptions): void;
+/**
+ * Validates SetCountdownOptions
+ *
+ * @param options - Options to validate
+ * @throws {ValidationError} If options are invalid
+ * @since 5.6.0
+ */
+export declare function validateSetCountdownOptions(options: SetCountdownOptions): void;
+/**
+ * Validates SetLanguageOptions
+ *
+ * @param options - Options to validate
+ * @throws {ValidationError} If options are invalid
+ * @since 5.6.0
+ */
+export declare function validateSetLanguageOptions(options: SetLanguageOptions): void;
+/**
+ * Validates GetStreamRoleOptions
+ *
+ * @param options - Options to validate
+ * @throws {ValidationError} If options are invalid
+ * @since 5.7.0
+ */
+export declare function validateGetStreamRoleOptions(options: GetStreamRoleOptions): void;
+/**
+ * Validates GetTokenAccessOptions
+ *
+ * @param options - Options to validate
+ * @throws {ValidationError} If options are invalid
+ * @since 5.11.0
+ */
+export declare function validateGetTokenAccessOptions(options: GetTokenAccessOptions): void;
+/**
+ * Recording parameters for stream configuration
+ *
+ * Configures recording output format, quality, and codec settings.
+ *
+ * @since 6.x.0
+ */
+export interface RecordingParamsDto {
+    /** Output format (mp4, webm, mkv, etc.) */
+    format: 'mp4' | 'webm' | 'mkv' | 'mov' | 'flv';
+    /** Video quality preset (480p, 720p, 1080p, 4k) */
+    quality: '480p' | '720p' | '1080p' | '4k';
+    /** Video bitrate in kbps (default: 2500) */
+    videoBitrate?: number;
+    /** Audio bitrate in kbps (default: 128) */
+    audioBitrate?: number;
+    /** Enable audio track */
+    includeAudio: boolean;
+    /** Enable video track */
+    includeVideo: boolean;
+    /** Frame rate (24, 30, 60) */
+    frameRate: 24 | 30 | 60;
+}
+/**
+ * Simulcast target parameters for stream configuration
+ *
+ * Configuration for streaming to external platforms (YouTube, Twitch, etc.).
+ *
+ * @since 6.x.0
+ */
+export interface SimulcastTargetParamsDto {
+    /** Display name for the target */
+    name: string;
+    /** Platform type (YOUTUBE, TWITCH, FACEBOOK, CUSTOM) */
+    platform: SimulcastPlatform;
+    /** RTMP URL for the streaming destination */
+    rtmpUrl: string;
+    /** Stream key for authentication */
+    streamKey: string;
+    /** Whether to automatically reconnect on failure */
+    autoReconnect?: boolean;
+    /** Maximum reconnection attempts */
+    maxRetries?: number;
+    /** Additional platform-specific parameters (JSON) */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Webhook simulation event types
+ *
+ * Types of events that can be simulated for webhook testing.
+ *
+ * @since 6.x.0
+ */
+export declare const SIMULATE_EVENT_TYPE: {
+    readonly STREAM_STARTED: "stream.started";
+    readonly STREAM_STOPPED: "stream.stopped";
+    readonly RECORDING_READY: "recording.ready";
+    readonly SIMULCAST_ERROR: "simulcast.error";
+};
+export type SimulateEventType = (typeof SIMULATE_EVENT_TYPE)[keyof typeof SIMULATE_EVENT_TYPE];
+/**
+ * Webhook simulation request data
+ *
+ * For testing webhook endpoint responses without waiting for real events.
+ *
+ * @since 6.x.0
+ */
+export interface SimulateWebhookDto {
+    /** Type of event to simulate */
+    eventType: SimulateEventType;
+    /** Token name for the event */
+    tokenName: string;
+    /** Optional event-specific payload */
+    payload?: Record<string, unknown>;
+}
+/**
+ * Result of Redis cache flush operation
+ *
+ * @since 6.x.0
+ */
+export interface FlushResult {
+    /** Whether the flush was successful */
+    success: boolean;
+    /** Number of keys flushed */
+    keysDeleted: number;
+    /** Timestamp of operation (ISO 8601) */
+    flushedAt: string;
+    /** Optional message describing the operation */
+    message?: string;
+}
+/**
+ * Complete stream settings response
+ *
+ * Consolidated response for all stream configuration settings.
+ * Field names aligned with backend stream configuration:
+ * - nextLiveStreamAt: Next scheduled stream time
+ * - language: Stream language (ISO 639-1 code), not streamLanguage
+ *
+ * @since 6.x.0
+ */
+export interface StreamSettingsResponse {
+    /** Token name */
+    tokenName: string;
+    /** Stream status (IDLE, ACTIVE, DISABLED) */
+    status: StreamStatus;
+    /** Countdown to next live stream (ISO 8601 or null) */
+    nextLiveStreamAt: string | null;
+    /** Stream language (ISO 639-1 code) - backend field: language, not streamLanguage */
+    language: string;
+    /** Recording parameters */
+    recordingParams: RecordingParamsDto;
+    /** Auto-record enabled */
+    autoRecordEnabled: boolean;
+    /** Simulcast targets */
+    simulcastTargets: SimulcastTarget[];
+    /** Last configuration update timestamp */
+    updatedAt: string;
+}
+/**
+ * Global streaming status response
+ *
+ * Platform-wide streaming enable/disable status.
+ *
+ * @since 6.x.0
+ */
+export interface GlobalStreamStatusResponse {
+    /** Whether streaming is enabled globally */
+    enabled: boolean;
+    /** When the status was last changed (ISO 8601) */
+    updatedAt: string;
+    /** Admin who changed the status */
+    updatedBy?: string;
+    /** Reason for disabling (if applicable) */
+    disableReason?: string;
+}
+/**
+ * Pinned chat message response
+ *
+ * @since 6.x.0
+ */
+export interface PinnedMessageResponse {
+    /** Message ID */
+    id: string;
+    /** Token name */
+    tokenName: string;
+    /** Message content */
+    content: string;
+    /** User who sent the message */
+    userAddress: string;
+    /** User display name */
+    userName?: string;
+    /** When the message was pinned */
+    pinnedAt: string;
+    /** Who pinned the message */
+    pinnedBy: string;
+    /** Reason for pinning (optional) */
+    reason?: string;
+}
+/**
+ * Chat status response
+ *
+ * Enable/disable status of chat for a token stream.
+ *
+ * @since 6.x.0
+ */
+export interface ChatStatusResponse {
+    /** Token name */
+    tokenName: string;
+    /** Whether chat is enabled */
+    enabled: boolean;
+    /** When the status was last changed */
+    updatedAt: string;
+    /** Admin who changed the status */
+    updatedBy?: string;
+    /** Reason for disabling chat (if applicable) */
+    disableReason?: string;
+    /** Current user count in chat */
+    activeUsers?: number;
+}
+/**
+ * Stream control status response
+ *
+ * Enable/disable status of stream controls (start/stop/reset key).
+ *
+ * @since 6.x.0
+ */
+export interface StreamControlStatusResponse {
+    /** Token name */
+    tokenName: string;
+    /** Whether stream controls are enabled */
+    enabled: boolean;
+    /** When status was last changed */
+    updatedAt: string;
+    /** Admin who changed the status */
+    updatedBy?: string;
+}
+/**
+ * Overall streaming configuration response
+ *
+ * Complete consolidated streaming configuration for a token.
+ *
+ * @since 6.x.0
+ */
+export interface OverallStreamingConfigResponse {
+    /** Token name */
+    tokenName: string;
+    /** Basic stream info */
+    stream: StreamInfo;
+    /** Settings (countdown, language, recording, etc.) */
+    settings: StreamSettingsResponse;
+    /** Chat status */
+    chatStatus: ChatStatusResponse;
+    /** Stream controls status */
+    controlsStatus: StreamControlStatusResponse;
+    /** Global streaming enabled */
+    globalStreamingEnabled: boolean;
+    /** Global chat enabled */
+    globalChatEnabled: boolean;
+    /** Consolidation timestamp */
+    retrievedAt: string;
+}
+//# sourceMappingURL=streaming.dto.d.ts.map