@lumiastream/ui 0.2.8-alpha.8 → 0.2.9

package/dist/se-import.d.ts

@@ -0,0 +1,444 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ComponentType, ReactNode } from 'react';
+
+type ModuleType = 'alert' | 'emotebox' | 'emotealert' | 'text' | 'image' | 'audio' | 'video' | 'camera' | 'slideshow' | 'shape' | 'svg' | 'colorbox' | 'goal' | 'timer' | 'gradientlight' | 'browsersource' | 'chatbox' | 'credits' | 'eventlist' | 'eventrotate' | 'hfx' | 'hfxalert' | 'clip' | 'youtube' | 'spinwheel' | 'raffle' | 'viewerqueue' | 'loyaltyleaderboard' | 'viewerprofiles' | 'achievements' | 'poll' | 'tournaments' | 'spotify' | 'nowplaying' | 'youtubemusic' | 'brbscreen' | 'vlc' | 'tts' | 'livecaption' | 'custom' | 'tipjar' | 'hypetrain' | 'streamboss' | 'songrequest' | 'group';
+type OverlayLayerType = 'layer' | 'group';
+type OverlayLayerBounds = {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+    scale: [number, number];
+    opacity?: number;
+    rotate?: number;
+    zIndex?: number;
+    matrix?: string;
+    clipPath?: string;
+    autoWidth?: boolean;
+    autoHeight?: boolean;
+};
+type OverlayLayerState = {
+    id: string;
+    group?: string | null;
+    type?: OverlayLayerType;
+    state: {
+        visible?: boolean;
+        locked?: boolean;
+        expanded?: boolean;
+    };
+    bounds: OverlayLayerBounds;
+};
+type OverlayModuleAlertState = {
+    events?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type OverlayModuleState = {
+    id?: string;
+    loaded?: boolean;
+    version?: number;
+    settings?: {
+        title?: string | null;
+        type?: ModuleType;
+        locked?: boolean;
+    };
+    lights?: unknown[];
+    css?: Record<string, string | number>;
+    content?: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+    events?: Record<string, unknown>;
+    alert?: OverlayModuleAlertState;
+};
+type OverlaySettings = {
+    layers: OverlayLayerState[];
+    metadata: {
+        width: number;
+        height: number;
+    };
+    modules: Record<string, OverlayModuleState>;
+};
+type OverlayState = {
+    uuid: string;
+    listen_id: string;
+    name: string;
+    description?: string;
+    settings: OverlaySettings;
+    metadata?: {
+        width: number | null;
+        height: number | null;
+    } | null;
+    layers_count?: number | null;
+    hasFullSettings?: boolean;
+};
+
+interface SEBootstrapResponse {
+    overlay: SEOverlay;
+    session?: unknown;
+    tipping?: unknown;
+    channel?: unknown;
+    passport?: unknown;
+}
+interface SEOverlay {
+    _id: string;
+    channel?: string;
+    type?: string;
+    name?: string;
+    preview?: string;
+    settings: {
+        width: number;
+        height: number;
+        name?: string;
+    };
+    widgets: SEWidget[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface SEWidget {
+    id: number | string;
+    group?: string | null;
+    version?: number | string | null;
+    type: string;
+    name?: string | null;
+    visible?: boolean;
+    locked?: boolean;
+    listener?: string | null;
+    listeners?: Record<string, boolean> | string[] | null;
+    provider?: string;
+    css: SECss;
+    text?: SEText;
+    image?: SEImage;
+    video?: SEVideo;
+    audio?: SEAudio;
+    variables?: Record<string, unknown>;
+}
+interface SECss {
+    'z-index'?: number;
+    width: string | number;
+    height: string | number;
+    opacity?: number;
+    top?: string | number;
+    left?: string | number;
+    transform?: string;
+}
+interface SEText {
+    type?: string;
+    value?: string | null;
+    enableShadow?: boolean;
+    scrolling?: {
+        direction?: string;
+        speed?: number;
+        enabled?: boolean;
+    };
+    css?: Record<string, unknown>;
+}
+interface SEImage {
+    type?: string;
+    src?: string;
+    css?: Record<string, unknown>;
+}
+interface SEVideo {
+    type?: string;
+    src?: string;
+    volume?: number;
+    css?: Record<string, unknown>;
+}
+interface SEAudio {
+    src?: string;
+    volume?: number;
+}
+interface ImportCoverage {
+    totalWidgets: number;
+    mappings: Array<{
+        seType: string;
+        lumiaType: string;
+        status: 'direct' | 'partial' | 'template' | 'placeholder';
+        count: number;
+    }>;
+    notes: string[];
+}
+interface ReviewItem {
+    moduleId: string;
+    seWidget: SEWidget;
+    status: 'placeholder' | 'template';
+    reason: string;
+    flaggedOff?: boolean;
+}
+
+/** Distinct SE CDN URLs referenced anywhere inside the overlay's settings. */
+declare function findSEAssetURLs(overlay: OverlayState): string[];
+/** Return a new overlay with every `oldUrl → newUrl` replacement applied. */
+declare function rewriteAssetURLs(overlay: OverlayState, mapping: Record<string, string>): OverlayState;
+interface AssetMirrorProgress {
+    url: string;
+    state: 'pending' | 'fetching' | 'uploading' | 'done' | 'failed';
+    newUrl?: string;
+    error?: string;
+}
+/**
+ * Mirror a single SE asset to Lumia storage via the existing `/overlays/assets`
+ * upload endpoint. Returns the new Lumia URL on success.
+ *
+ * The host call site is responsible for retries and progress reporting; this
+ * function is intentionally single-shot. Pass `signal` (AbortSignal) to abort
+ * the source-side `fetch` when the modal closes mid-mirror — the upload itself
+ * is consumer-defined and the caller decides whether/how to short-circuit it.
+ *
+ * Bails out with a typed error if the SE server advertises a Content-Length
+ * over MAX_MIRROR_ASSET_BYTES (cheap pre-check) or if the downloaded blob
+ * exceeds the same cap (covers chunked responses where Content-Length is
+ * absent or lying).
+ */
+declare function mirrorOneAsset(url: string, upload: (file: File) => Promise<{
+    asset: {
+        url: string;
+    };
+} | {
+    url: string;
+} | unknown>, signal?: AbortSignal): Promise<string>;
+declare function filenameFromURL(url: string): string;
+
+interface TransplantedUnit {
+    layer: OverlayLayerState;
+    module: OverlayModuleState;
+    extras?: Array<{
+        layer: OverlayLayerState;
+        module: OverlayModuleState;
+    }>;
+}
+declare function transplantLayer(source: OverlayState, sourceLayerId: string): TransplantedUnit | null;
+declare function listTransplantableLayers(source: OverlayState): Array<{
+    id: string;
+    label: string;
+    type: string;
+}>;
+
+declare const SE_WIDGET_TO_MARKETPLACE_CANDIDATES: Record<string, number[]>;
+declare function getMarketplaceCandidates(seWidgetType: string): number[];
+declare function hasMarketplaceCandidates(seWidgetType: string): boolean;
+
+declare function isWidgetFlaggedOff(_seType: string): boolean;
+declare const FLAG_OFF_REASONS: Record<string, string>;
+
+interface SEAccountClaims {
+    channel: string;
+    user: string;
+    authToken: string;
+    provider: string;
+    provider_id: string;
+    role: string;
+    exp: number;
+    jti: string;
+    channel_id?: string;
+    user_id?: string;
+}
+type SEAuthErrorCode = 'invalid-jwt' | 'expired' | 'unauthorized' | 'forbidden';
+type SEAuthMode = 'apikey-authToken' | 'apikey-jwt' | 'bearer-jwt';
+declare class SEAuthError extends Error {
+    code: SEAuthErrorCode;
+    constructor(code: SEAuthErrorCode, message: string);
+}
+declare function decodeJwtPayload(jwt: string): SEAccountClaims;
+declare class SEClient {
+    private readonly claims;
+    private readonly jwt;
+    authMode: SEAuthMode;
+    constructor(claims: SEAccountClaims, jwt: string, authMode?: SEAuthMode);
+    static fromJwt(jwt: string, authMode?: SEAuthMode): SEClient;
+    withAuthMode(mode: SEAuthMode): SEClient;
+    private authHeader;
+    get channelId(): string;
+    get provider(): string;
+    get providerId(): string;
+    get userId(): string;
+    get jti(): string;
+    get expiresAt(): Date;
+    provenance(): {
+        jti: string;
+        channelId: string;
+        provider: string;
+        importedAt: string;
+    };
+    get<T>(path: string): Promise<T>;
+}
+interface SEChannelSummary {
+    _id: string;
+    provider: string;
+    providerId: string;
+    username: string;
+    alias?: string;
+    displayName?: string;
+    avatar?: string;
+    role?: string;
+    authorized?: boolean;
+    inactive?: boolean;
+    isPartner?: boolean;
+    broadcasterType?: string;
+}
+interface SEUsersCurrentResponse {
+    _id: string;
+    suspended?: boolean;
+    channels: SEChannelSummary[];
+}
+declare function fetchUsableChannels(client: SEClient): Promise<SEChannelSummary[]>;
+interface SEOverlaySummary {
+    _id: string;
+    name?: string;
+    type?: string;
+    preview?: string;
+    favorite?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    settings?: {
+        width?: number;
+        height?: number;
+        name?: string;
+    };
+}
+declare function fetchSEOverlays(client: SEClient, count?: number): Promise<SEOverlaySummary[]>;
+declare function fetchSEFiltersRaw(client: SEClient): Promise<unknown>;
+interface SEAuthProbeResult {
+    endpoint: string;
+    mode: SEAuthMode;
+    status: number;
+    ok: boolean;
+    errorMessage?: string;
+}
+interface SEAuthDiagnostic {
+    jwtPreview: string;
+    channelId: string;
+    results: SEAuthProbeResult[];
+}
+declare function diagnoseSEAuth(jwt: string): Promise<SEAuthDiagnostic>;
+
+interface SEExistingAsset {
+    file_name?: string;
+    name?: string;
+    url: string;
+}
+interface SECustomEmbedProps {
+    codeId: string;
+    html: string;
+    css: string;
+    js: string;
+    data: unknown;
+}
+interface SEUploadAssetResult {
+    url: string;
+    file_name?: string;
+    name?: string;
+}
+interface SESaveOverlayBody {
+    name: string;
+    description?: string;
+    image?: string;
+    images?: string[];
+    settings: OverlayState['settings'];
+}
+interface SEImportBindings {
+    fetchMarketplaceOverlay: (id: number) => Promise<OverlayState>;
+    generateAICustomCode: (prompt: string) => Promise<AIGeneratedCustomOverlay>;
+    uploadAsset: (file: File) => Promise<SEUploadAssetResult>;
+    existingAssets: SEExistingAsset[];
+    saveOverlay: (body: SESaveOverlayBody) => Promise<{
+        uuid: string;
+    }>;
+    onComplete: (result: {
+        overlayId: string;
+    }) => void;
+    onOverlayImported?: (result: {
+        overlayId: string;
+        sourceSEOverlayId?: string;
+        sourceSEOverlayName?: string;
+        width?: number;
+        height?: number;
+    }) => void;
+    onClose: () => void;
+    notify: {
+        success: (msg: string) => void;
+        error: (msg: string) => void;
+        warning: (msg: string) => void;
+    };
+    CustomEmbed?: ComponentType<SECustomEmbedProps>;
+    t?: (key: string) => string | undefined;
+    onAuthError?: (err: SEAuthError) => void;
+    onOpenFullImport?: () => void;
+}
+
+interface SEImportWizardProps {
+    bindings: SEImportBindings;
+    initialUrl?: string;
+    initialStep?: "mode" | "url" | "connect";
+    confirmActionLabel?: string;
+    importingActionLabel?: string;
+    initialJwt?: string;
+    initialOverlayIds?: string[];
+    initialOverlayList?: SEOverlaySummary[];
+}
+declare function SEImportWizard({ bindings, initialUrl, initialStep, confirmActionLabel, importingActionLabel, initialJwt, initialOverlayIds, initialOverlayList, }: SEImportWizardProps): react_jsx_runtime.JSX.Element;
+
+interface MarketplacePickerProps {
+    seWidgetType: string;
+    fetchMarketplaceOverlay: SEImportBindings['fetchMarketplaceOverlay'];
+    CustomEmbed?: SEImportBindings['CustomEmbed'];
+    onPick: (transplant: {
+        layer: OverlayLayerState;
+        module: OverlayModuleState;
+    }) => void;
+    onCancel: () => void;
+}
+declare function MarketplacePicker({ seWidgetType, fetchMarketplaceOverlay, CustomEmbed, onPick, onCancel }: MarketplacePickerProps): react_jsx_runtime.JSX.Element;
+
+declare const streamElementsCopyJwt: string;
+declare const JWT_DASHBOARD_URL = "https://streamelements.com/dashboard/account/channels";
+interface JwtInstructionStep {
+    content: ReactNode;
+}
+declare function getJwtInstructionSteps({ pasteHint }?: {
+    pasteHint?: string;
+}): JwtInstructionStep[];
+
+interface ImportResult {
+    overlay: OverlayState;
+    coverage: ImportCoverage;
+    reviewItems: ReviewItem[];
+}
+declare function extractSEOverlayId(input: string): string | null;
+declare function extractSEPreviewParts(input: string): {
+    overlayId: string;
+    apikey: string | null;
+} | null;
+declare function buildBootstrapUrl(overlayId: string): string;
+declare function fetchSEBootstrap({ overlayId, apikey, }: {
+    overlayId: string;
+    apikey: string | null;
+}): Promise<SEBootstrapResponse>;
+declare function isSEBootstrap(value: unknown): value is SEBootstrapResponse;
+declare function importSEBootstrap(bootstrap: SEBootstrapResponse): ImportResult;
+interface AIGeneratedCustomOverlay {
+    codeId?: string;
+    html?: string;
+    css?: string;
+    js?: string;
+    data?: unknown;
+    configs?: unknown;
+}
+declare function applyReviewAction(result: ImportResult, moduleId: string, action: "keep" | "skip" | "ai" | "marketplace", payload?: AIGeneratedCustomOverlay | {
+    layer: OverlayLayerState;
+    module: OverlayModuleState;
+    extras?: Array<{
+        layer: OverlayLayerState;
+        module: OverlayModuleState;
+    }>;
+}): ImportResult;
+declare function getAILandingBounds(widget: SEWidget, canvas?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+};
+declare function buildAIPromptForSEWidget(widget: SEWidget, canvas?: {
+    width: number;
+    height: number;
+}): string;
+
+export { type AIGeneratedCustomOverlay, type AssetMirrorProgress, FLAG_OFF_REASONS, type ImportCoverage, type ImportResult, JWT_DASHBOARD_URL, type JwtInstructionStep, MarketplacePicker, type MarketplacePickerProps, type ModuleType, type OverlayLayerBounds, type OverlayLayerState, type OverlayLayerType, type OverlayModuleAlertState, type OverlayModuleState, type OverlaySettings, type OverlayState, type ReviewItem, type SEAccountClaims, type SEAuthDiagnostic, SEAuthError, type SEAuthErrorCode, type SEAuthMode, type SEAuthProbeResult, type SEBootstrapResponse, type SEChannelSummary, SEClient, type SECustomEmbedProps, type SEExistingAsset, type SEImportBindings, SEImportWizard, type SEImportWizardProps, type SEOverlaySummary, type SESaveOverlayBody, type SEUploadAssetResult, type SEUsersCurrentResponse, type SEWidget, SE_WIDGET_TO_MARKETPLACE_CANDIDATES, type TransplantedUnit, applyReviewAction, buildAIPromptForSEWidget, buildBootstrapUrl, decodeJwtPayload, diagnoseSEAuth, extractSEOverlayId, extractSEPreviewParts, fetchSEBootstrap, fetchSEFiltersRaw, fetchSEOverlays, fetchUsableChannels, filenameFromURL, findSEAssetURLs, getAILandingBounds, getJwtInstructionSteps, getMarketplaceCandidates, hasMarketplaceCandidates, importSEBootstrap, isSEBootstrap, isWidgetFlaggedOff, listTransplantableLayers, mirrorOneAsset, rewriteAssetURLs, streamElementsCopyJwt, transplantLayer };