@stripchatdev/ext-helper 0.1.44 → 0.1.45

package/dist/helpers/index.d.ts

@@ -0,0 +1,1025 @@
+/**
+ * Create a state client for a visual slot.
+ *
+ * Use the same channel as the background host. The client starts with
+ * `isLoading: true` and `state: null`, then exposes the state received from the
+ * host. `setState()` sends a partial update; the state changes when the host
+ * publishes the resulting state.
+ *
+ * @typeParam State - Shape of the state shared through the channel.
+ * @param channel - Channel name shared with the background host.
+ * @param extHelper - Extension helper used for local slot communication.
+ * @returns A client for reading, updating, and subscribing to shared state.
+ */
+export declare const createSlotStateClient: <State extends object>({ channel, extHelper, }: TCreateSlotStateClientProps) => TSlotStateClient<State>;
+
+/**
+ * Create a state host for a background slot.
+ *
+ * The background slot owns the shared state. Visual slots use the same channel
+ * to read the state and send partial updates.
+ *
+ * Create one host for each channel and call `unsubscribe()` when it is no longer
+ * needed. Visual slots should use `createSlotStateClient` or `useSlotState`.
+ *
+ * @typeParam State - Shape of the state shared through the channel.
+ * @param channel - Channel name shared with the visual-slot clients.
+ * @param extHelper - Extension helper used for local slot communication.
+ * @param initialState - Initial state owned by the background slot.
+ * @returns A controller for reading, updating, and stopping the host.
+ */
+export declare const createSlotStateHost: <State extends object>({ channel, extHelper, initialState, }: TCreateSlotStateHostProps<State>) => TSlotStateHost<State>;
+
+declare type IV1IntIncrementFailureReason = 'INT_INCREMENT_FAILURE_REASON_UNSPECIFIED' | 'INT_INCREMENT_FAILURE_REASON_NONE' | 'INT_INCREMENT_FAILURE_REASON_VALIDATION_DENIED';
+
+declare type TAnyApiEventData<D = unknown> = D;
+
+declare type TAnyApiEventName = string;
+
+declare type TAnyApiMethodMeta<P = unknown, R = unknown> = {
+    params: P;
+    result: R;
+};
+
+declare type TAnyApiMethodName = string;
+
+declare type TAnyApiSchema<Events extends Record<TAnyApiEventName, TAnyApiEventData> = Record<TAnyApiEventName, TAnyApiEventData>, Methods extends Record<TAnyApiMethodName, TAnyApiMethodMeta> = Record<TAnyApiMethodName, TAnyApiMethodMeta>> = {
+    events: Events;
+    methods: Methods;
+};
+
+declare type TAnyPubSubHandler<D = unknown> = (data: D, peerId: TTransportPeer['id']) => void;
+
+declare type TApiContract = TApiSchema;
+
+declare type TApiSchema = TAnyApiSchema<TEvents, TMethods>;
+
+/** Options for connecting a visual slot to shared background state. */
+export declare type TCreateSlotStateClientProps = {
+    /** Shared name for the state. */
+    channel: string;
+    /** Extension helper used for slot communication. */
+    extHelper: TExtHelper;
+};
+
+/** Options for creating shared state owned by a background slot. */
+export declare type TCreateSlotStateHostProps<State extends object> = TCreateSlotStateClientProps & {
+    /** Initial shared state. */
+    initialState: State;
+};
+
+declare type TEvents = TV1Events;
+
+declare type TExtHelper = {
+    bootstrap(): void;
+    makeRequest<M extends Extract<keyof TApiContract['methods'], string>>(method: M, params: TApiContract['methods'][M]['params']): Promise<TApiContract['methods'][M]['result']>;
+    subscribe<E extends Extract<keyof TApiContract['events'], string>>(eventName: E, handler: TAnyPubSubHandler<TApiContract['events'][E]>): void;
+    unsubscribe<E extends Extract<keyof TApiContract['events'], string>>(eventName: E, handler?: TAnyPubSubHandler<TApiContract['events'][E]>): void;
+};
+
+/** Unique identifier for a guest user **/
+declare type TGuestHash = string;
+
+declare type TMethods = TV1Methods;
+
+/**
+ * Status of the movable overlay.
+ * `active` - pulsing green
+ * `inactive` - orange
+ * `connecting` - green
+ * `error` - red
+ */
+declare type TMovableOverlayStatus = 'active' | 'inactive' | 'connecting' | 'error';
+
+/** Client for reading and updating state owned by a background slot. */
+export declare type TSlotStateClient<State extends object> = {
+    /** Return the current state and loading status. */
+    getSnapshot: () => TSlotStateSnapshot<State>;
+    /** Send a shallow partial update to the background slot. */
+    setState: (newState: Partial<State>) => Promise<void>;
+    /** Subscribe to state changes and return an unsubscribe function. */
+    subscribe: (listener: () => void) => () => void;
+};
+
+/** Controls shared state owned by a background slot. */
+export declare type TSlotStateHost<State extends object> = {
+    /** Return the current state. */
+    getState: () => State;
+    /** Apply a shallow partial update and publish the new state. */
+    setState: (newState: Partial<State>) => Promise<void>;
+    /** Stop sharing this state. */
+    unsubscribe: () => void;
+};
+
+/** Current shared state exposed by a visual-slot client. */
+export declare type TSlotStateSnapshot<State extends object> = {
+    /** Whether the initial state is still loading. */
+    isLoading: boolean;
+    /** The current state, or `null` while loading. */
+    state: State | null;
+};
+
+declare type TTransportPeer = {
+    id: string;
+};
+
+declare type TUnknownDictionary = Record<string, unknown>;
+
+declare type TUserId = number;
+
+declare type TV1ActionParamValue = string | number | boolean | null | undefined | TV1ActionParamValue[] | {
+    [key: string]: TV1ActionParamValue;
+};
+
+declare type TV1ActionRequestParams = {
+    actionName: string;
+    params: Record<string, TV1ActionParamValue>;
+};
+
+declare type TV1ActionResult = {
+    body: unknown;
+    code: number;
+};
+
+declare type TV1ChatEvents = {
+    /** Triggered on every new message in a chat */
+    'v1.chat.message.received': {
+        /** Text of the message */
+        messageText: string;
+        /** User who sent the message **/
+        sender: TV1ExtUser;
+        /** Whether message was sent in public or private chat **/
+        type: 'private' | 'public';
+    };
+};
+
+declare type TV1ChatMethods = {
+    /**
+     * This method should be used to notify a user in the chat about an event related to the extension, for example, showing the result of a game. Therefore, it should be used only after `v1.payment.tokens.spend.succeeded` event.
+     *
+     * The message is sent locally to each user on behalf of the extension. The message is not sent to the server
+     * and is not broadcasted — each user sees it injected into their own local chat feed.
+     *
+     * Because the message is local only, it is **not persisted**: it will disappear from the chat
+     * history after the page is reloaded.
+     *
+     * **Note:** A clickable link to the extension is always appended at the end of every message sent via this method.
+     * Clicking it opens the extension that sent the message.
+     * This behavior is mandatory and cannot be disabled.
+     */
+    'v1.chat.message.send': {
+        params: {
+            /** Whether the username should be hidden. Always respect user's anonimity and use data received in `v1.payment.tokens.spend.succeeded'. */
+            isAnonymous: boolean;
+            /**
+             * Chat message text.
+             *
+             * Supports inline markup tags:
+             * - `{#accent}…{/accent}` — highlights text with an accent color.
+             * - `{#fade}…{/fade}` — renders text in a dimmed/secondary style.
+             *
+             * Example: `'won {#accent}Alice{/accent} in'`
+             */
+            message: string;
+            user: TV1ExtUser | null;
+        };
+        result: null;
+    };
+    /** Use this method to send a message in the chat as a bot or model.
+     *  The message is sent locally to each user and looks like a normal chat message. The message is **not persisted** and will disappear from the chat after the page is reloaded.
+     * */
+    'v1.chatbot.message.send': {
+        params: {
+            /** Sender of the message.
+             * If `bot`, the message will be sent with the name of the extension
+             * If `model`, the message will be sent with the name of the current model
+             * */
+            from: 'bot' | 'model';
+            /** Text of the message.
+             *
+             *
+             *  The message can contain {username} placeholder, which will be replaced with the name of the user receiving the message.
+             *  If the user is anonymous, the placeholder will be replaced with empty string.
+             *  If the user is guest, the placeholder will be replaced with "Guest".
+             *
+             *  Example usage: "Hello, {username}! Welcome to the chat!"
+             * */
+            message: string;
+        };
+        result: null;
+    };
+};
+
+declare type TV1Events = TV1ExtEvents & TV1PaymentEvents & TV1ModelEvents & TV1SessionEvents & TV1TipEvents & TV1ChatEvents & TV1GoalEvents;
+
+declare type TV1ExtContext = {
+    model?: TV1ExtModel;
+    /** Unique identifier for the extension. */
+    slug?: string;
+    user?: TV1ExtUser;
+};
+
+declare type TV1ExtEvents = {
+    'v1.ext.activity.available': null;
+    'v1.ext.activity.busy': null;
+    'v1.ext.context.updated': {
+        context: TV1ExtContext;
+    };
+    /**
+     * Fired whenever the viewer counts for the room change.
+     * Emitted only for show types: `public`, `groupShow`, `ticketShow`.
+     */
+    'v1.ext.viewers.updated': {
+        viewers: TV1ExtViewers;
+    };
+    'v1.ext.whispered': TV1WhisperData;
+    'v1.ext.whispered.local': TV1WhisperData;
+};
+
+/** Guest user (not logged in). */
+declare type TV1ExtGuestUser = {
+    /** Unique identifier for a guest user. */
+    guestHash: TGuestHash;
+    /** User is a guest (not logged in). */
+    isGuest: true;
+};
+
+/** Logged-in user. */
+declare type TV1ExtLoggedInUser = {
+    /** User's fan club data. Contains information regarding user's subscription to the model's fan club.  */
+    fanClub: TV1UsersFanClub;
+    /** User previously purchased tokens. */
+    hasPaidBefore: boolean;
+    /** User has tokens. */
+    hasTokens: boolean;
+    /** User currently has Ultimate membership. */
+    hasUltimateSubscription: boolean;
+    /** User ID. */
+    id: TUserId;
+    /** User is logged in. */
+    isGuest: false;
+    /** User is invisible. Do not expose any data of invisible users. */
+    isInvisible: boolean;
+    /** User is the highest tipper in the room over past 12 hours. */
+    isKing: boolean;
+    /** User is a knight of the model. */
+    isKnight: boolean;
+    /**
+     * User has a model account.
+     *
+     * This can be true for another model visiting the stream. To check whether the
+     * current user is the broadcaster, compare `context.user.id`
+     * and `context.model.id`.
+     */
+    isModel: boolean;
+    /**
+     * Current show/session state for this user.
+     *
+     * - `public` — public broadcast context
+     * - `private` — private show context
+     * - `exclusivePrivate` — exclusive private show context
+     * - `groupShow` — group show context
+     * - `ticketShow` — ticket show context
+     * - `off` — offline
+     * - `spy` — spying on a private show
+     */
+    status: TV1UserStatus;
+    /** User username. */
+    username: string;
+    /** User activity ranking data when available. */
+    userRanking?: TV1UserRanking;
+};
+
+declare type TV1ExtMethods = {
+    'v1.ext.actions.call': {
+        params: TV1ActionRequestParams;
+        result: TV1ActionResult;
+    };
+    'v1.ext.activity.request': {
+        params: {
+            durationMs: number;
+        };
+        result: {
+            activityId: string;
+        };
+    };
+    'v1.ext.activity.status': {
+        params: null;
+        result: {
+            status: 'available' | 'busy';
+        };
+    };
+    'v1.ext.context.get': {
+        params: null;
+        result: TV1ExtContext;
+    };
+    'v1.ext.movableOverlay.update': {
+        params: {
+            message?: string;
+            status?: TMovableOverlayStatus;
+        };
+        result: null;
+    };
+    'v1.ext.settings.get': {
+        params: null;
+        result: {
+            settings: TV1ExtSettings;
+        };
+    };
+    /** Opens Stripchat sign-up dialog for anonymous users. Use this when your extension requires a registered account to function */
+    'v1.ext.signup.open': {
+        params: {
+            type: 'user';
+        };
+        result: null;
+    };
+    /**
+     * Returns the current viewer counts for the room.
+     * Supported only for show types: `public`, `groupShow`, `ticketShow`.
+     * Returns `null` for other show types.
+     */
+    'v1.ext.viewers.get': {
+        params: null;
+        result: TV1ExtViewers | null;
+    };
+    /** Broadcasts a message through the server to all clients in the room that have this extension loaded. Every slot iframe of every user receives the corresponding `v1.ext.whispered` event */
+    'v1.ext.whisper': {
+        params: {
+            /** Any JSON-serializable object to send to every frame.
+             * Never send any sensetive data through this field, such as username or user id.
+             * */
+            data: TV1WhisperData;
+            /** @deprecated
+             * Use `paymentHash` instead
+             *
+             * Payment data returned by the `payment.tokens.spend.succeeded` event.
+             *  Required for users in public shows. Use it only once for the request it authorizes. Do not store or reuse it.
+             * */
+            paymentData?: TV1PaymentData;
+            /** Payment hash returned by the `payment.tokens.spend.succeeded` event.
+             * Payment hash is used for authentication. Required for users in public shows. Use it only once for the request it authorizes. Do not store or reuse it.
+             * */
+            paymentHash?: TV1PaymentHash;
+        };
+        result: null;
+    };
+    /** Sends a message to every frame of the current user */
+    'v1.ext.whisper.local': {
+        params: {
+            data: TV1WhisperData;
+        };
+        result: null;
+    };
+};
+
+declare type TV1ExtModel = {
+    /** Model's avatar url */
+    avatarUrlThumb: string;
+    /** @deprecated use isExclusivePrivateEnabled instead. This property will be removed soon */
+    doP2p: boolean;
+    /** @deprecated use isPrivateEnabled instead. This property will be removed soon */
+    doPrivate: boolean;
+    /** Broadcasting gender. Could be one of the male, female, tranny or group */
+    gender: TV1Genders;
+    id: TUserId;
+    /** Is exclusive private mode enabled on the stream */
+    isExclusivePrivateEnabled: boolean;
+    /** Is non nude model */
+    isNonNude: boolean;
+    /** Is private mode enabled on the stream */
+    isPrivateEnabled: boolean;
+    /** Is spy mode enabled on the stream */
+    isSpyEnabled: boolean;
+    /** Model's name from her profile. If not set, an empty string will be returned */
+    name: string;
+    /** Status of the show. Possible values:
+     *
+     * - `idle` - model is online but not streaming
+     * - `public` - model is broadcasting public show
+     * - `private` - model is in private show
+     * - `exclusivePrivate` - model is in exclusive private show
+     * - `off` - model is offline
+     * - `groupShow` - model is in group show that is not a ticket show
+     * - `ticketShow` - model is in ticket show
+     * */
+    status: TV1ModelStatus;
+    /** Model's username */
+    username: string;
+};
+
+declare type TV1ExtSettings = unknown;
+
+declare type TV1ExtUser = TV1ExtGuestUser | TV1ExtLoggedInUser;
+
+/** Viewer counts for the current room. */
+declare type TV1ExtViewers = {
+    /** Number of guest (unauthenticated) viewers. */
+    guests: number;
+    /** Total number of viewers in the room. */
+    total: number;
+    /** Number of viewers who hold tokens. */
+    withTokens: number;
+};
+
+declare type TV1FanClubMethods = {
+    /**
+     * Opens the fan club subscription modal for the current model.
+     * Read `context.user.fanClub` from the extension context to verify the user is eligible before calling.
+     * This field is available only for logged-in users (`context.user.isGuest === false`).
+     * Pass `null` for params to open the modal with the `soldier` tab selected by default.
+     */
+    'v1.fanClub.request': {
+        params: {
+            /** Which tier tab to show in the modal. */
+            tier: TV1FanClubTier;
+        } | null;
+        result: null;
+    };
+};
+
+/**
+ * Fan club subscription tier. Ordered from lowest to highest:
+ * - `soldier` — first tier with basic benefits
+ * - `lord` — second tier with more benefits than `soldier`
+ * - `prince` — third tier with the most benefits
+ */
+declare type TV1FanClubTier = 'soldier' | 'lord' | 'prince';
+
+declare type TV1Genders = 'male' | 'female' | 'group' | 'tranny';
+
+/** Regular goal data */
+declare type TV1GoalData = {
+    /** Goal description */
+    description: string;
+    /** Whether the goal is fully completed */
+    isCompleted: boolean;
+    /** Amount of tokens already collected */
+    tokensCollected: number;
+    /** Target amount in tokens */
+    tokensTarget: number;
+};
+
+declare type TV1GoalEvents = {
+    /** Fired when any field of the active goal changes (description, isCompleted, tokensTarget, or tokensCollected), or the active goal is removed. */
+    'v1.goal.updated': {
+        goal: TV1GoalData | null;
+    };
+};
+
+declare type TV1GoalMethods = {
+    /** Get the current active goal. Returns null if no goal is active. */
+    'v1.goal.get': {
+        params: null;
+        result: {
+            goal: TV1GoalData | null;
+        };
+    };
+};
+
+declare type TV1Methods = TV1ExtMethods & TV1SystemMethods & TV1PaymentMethods & TV1ModelMethods & TV1ChatMethods & TV1PrivateMethods & TV1MonitoringMethods & TV1SessionMethods & TV1StorageMethods & TV1TipMethods & TV1GoalMethods & TV1FanClubMethods;
+
+declare type TV1ModelEvents = {
+    'v1.model.ext.settings.set.requested': null;
+};
+
+declare type TV1ModelMethods = {
+    'v1.model.ext.settings.get': {
+        params: null;
+        result: {
+            settings: TV1ExtSettings;
+        };
+    };
+    'v1.model.ext.settings.set': {
+        params: {
+            isError: boolean;
+            settings: TV1ExtSettings;
+        };
+        result: null;
+    };
+};
+
+declare type TV1ModelStatus = Exclude<(typeof V1_SHOW_STATUSES)[keyof typeof V1_SHOW_STATUSES], 'spy'>;
+
+declare type TV1MonitoringMethods = {
+    'v1.monitoring.report.error': {
+        params: {
+            data: unknown;
+            message: string;
+        };
+        result: null;
+    };
+    'v1.monitoring.report.log': {
+        params: {
+            data: unknown;
+            message: string;
+        };
+        result: null;
+    };
+};
+
+/** Payment data returned after a successful token spend. Use it only once for the request it authorizes. Do not store or reuse it. */
+declare type TV1PaymentData = {
+    /** The amount of tokens spent */
+    amount: string;
+    /** Payment token used for authentication */
+    paymentToken: string;
+    /** Transaction identifier */
+    transactionId: string;
+    /** User's ID */
+    userId: string;
+};
+
+declare type TV1PaymentEvents = {
+    /**
+     * Received when tokens are successfully spent
+     * Contains payment data returned after a successful token spend. Use it only once for the request it authorizes. Do not store or reuse it.
+     */
+    'v1.payment.tokens.spend.succeeded': {
+        /** Was the tip anonymous. Use this field in `v1.chat.message.send` */
+        isAnonymous: boolean;
+        /** @deprecated
+         * Use `paymentHash` instead.
+         *
+         * Payment data returned after a successful token spend. Use it only once for the request it authorizes. Do not store or reuse it. */
+        paymentData: TV1PaymentData;
+        /**
+         * Payment hash used for authentication. Required for users in public shows. Use it only once for the request it authorizes. Do not store or reuse it.
+         */
+        paymentHash: TV1PaymentHash;
+        /** Custom data passed in `payment.tokens.spend` method */
+        tokensSpendData: TV1TokenSpendData;
+    };
+};
+
+/** Payment hash used for authentication. Do not store or reuse it. Use it only once for the request it authorizes. */
+declare type TV1PaymentHash = string;
+
+declare type TV1PaymentMethods = {
+    /** Requests a confirmation modal to spend tokens */
+    'v1.payment.tokens.spend': {
+        params: {
+            /** Amount of tokens to spend */
+            tokensAmount: number;
+            /** Custom data which will be passed back in the `v1.payment.tokens.spend.succeeded` event */
+            tokensSpendData: TV1TokenSpendData;
+        };
+        result: null;
+    };
+    /** Opens the token top-up (purchase) modal directly, sending the user straight to buying tokens — without
+     *  the spend-confirmation step of `v1.payment.tokens.spend`. Use it for an explicit "Buy tokens" CTA. */
+    'v1.payment.tokens.topup': {
+        params: null;
+        result: null;
+    };
+};
+
+declare type TV1PrivateMethods = {
+    'v1.private.request': {
+        params: null;
+        result: null;
+    };
+};
+
+declare type TV1SerializedError = {
+    cause?: TV1SerializedError;
+    message: string;
+    name: string;
+    stack?: string;
+};
+
+declare type TV1Session = TV1SessionSelf | TV1SessionOther;
+
+declare type TV1SessionActionType = 'join' | 'finish';
+
+declare type TV1SessionEvents = {
+    'v1.session.updated': {
+        data: TV1SessionUpdate;
+    };
+    'v1.session.whispered.model': TV1SessionWhisperData;
+};
+
+declare type TV1SessionMethods = {
+    'v1.session.finish.model': {
+        params: null;
+        result: null;
+    };
+    'v1.session.get': {
+        params: null;
+        result: {
+            session: TV1Session | null;
+        };
+    };
+    'v1.session.join.model': {
+        params: {
+            ttl: string;
+        };
+        result: null;
+    };
+    'v1.session.join.user': {
+        params: {
+            /** @deprecated
+             * Use `paymentHash` instead.
+             *
+             * Payment data returned by the `payment.tokens.spend.succeeded` event. Use it only once for the request it authorizes. Do not store or reuse it. */
+            payment?: TV1PaymentData;
+            /**
+             * Payment hash returned by the `payment.tokens.spend.succeeded` event.
+             * Use it only once for the request it authorizes. Do not store or reuse it.
+             */
+            paymentHash: TV1PaymentHash;
+            /** Session lifetime in seconds (minimum 1). */
+            ttl: string;
+        };
+        result: null;
+    };
+    'v1.session.whisper.user': {
+        params: {
+            data: TV1SessionWhisperData;
+        };
+        result: null;
+    };
+};
+
+declare type TV1SessionOther = {
+    /** The session exists but belongs to a different extension */
+    owner: 'other';
+};
+
+declare type TV1SessionSelf = {
+    meta: {
+        /** Platform session id */
+        sessionId: string;
+        /** Remaining lifetime in seconds */
+        ttlSec: number;
+    };
+    /** The session exists and belongs to this extension */
+    owner: 'self';
+};
+
+declare type TV1SessionUpdate = {
+    action: TV1SessionActionType;
+    session: TV1Session | null;
+    userId: TUserId;
+};
+
+declare type TV1SessionWhisperData = TUnknownDictionary;
+
+declare type TV1StorageMethods = {
+    'v1.storage.int.get': {
+        params: {
+            key: string;
+        };
+        result: {
+            /** `false` when the key has never been set (value will be 0). */
+            exists?: boolean;
+            /** @format int64 */
+            value: string;
+        };
+    };
+    /**
+     * Add `delta` to an integer counter. Negative delta subtracts.
+     * When the key is configured with a payment policy, pass `paymentContext`
+     * so the server can validate the transaction before applying the change.
+     */
+    'v1.storage.int.increment': {
+        params: {
+            /** Amount to add (may be negative). Must not be zero. */
+            delta: string;
+            key: string;
+            /** Opaque payload forwarded to server-side payment/policy validation. */
+            paymentContext?: string;
+        };
+        result: {
+            failureReason?: IV1IntIncrementFailureReason;
+            /** New counter value after the increment (present when `success` is true). */
+            success: boolean;
+            value?: string;
+        };
+    };
+    /** Reset an integer counter to 0. */
+    'v1.storage.int.reset': {
+        params: {
+            key: string;
+        };
+        result: {
+            success: boolean;
+            /** Stored value after reset; always 0 when `success` is true. */
+            value?: string;
+        };
+    };
+    'v1.storage.mutex.getState': {
+        params: {
+            mutexName: string;
+        };
+        result: {
+            /** `true` if the mutex is currently locked. */
+            held: boolean;
+        };
+    };
+    'v1.storage.mutex.lock': {
+        params: {
+            mutexName: string;
+            /** Auto-release after this many seconds. Omit or 0 = hold until explicit unlock. */
+            /** @format int64 */
+            ttl?: string;
+        };
+        result: {
+            success: boolean;
+        };
+    };
+    'v1.storage.mutex.unlock': {
+        params: {
+            mutexName: string;
+        };
+        result: {
+            success: boolean;
+        };
+    };
+    'v1.storage.string.append': {
+        params: {
+            key: string;
+            /** Auto-delete the key after this many seconds. Omit or 0 = no expiry. */
+            /** @format int64 */
+            ttl?: string;
+            value: string;
+        };
+        result: {
+            success: boolean;
+        };
+    };
+    'v1.storage.string.get': {
+        params: {
+            /**
+             * When `true`, read the single extension-wide value shared across every room and viewer
+             * instead of the value scoped to the current room and viewer. Use for shared data seeded
+             * on the server. Defaults to `false` (per-room read).
+             */
+            all?: boolean;
+            key: string;
+        };
+        result: {
+            /** `false` when the key has never been set (value will be `''` empty string).  */
+            exists: boolean;
+            /**
+             * Server time (UTC, RFC3339) at which the response was generated. Use this instead of the device
+             * clock for time-window logic — a skewed local clock won't desync the extension. Optional so a host
+             * that doesn't yet surface it still validates (newer hosts always include it).
+             */
+            time?: string;
+            /** Stored string value. Empty string if the key was never set. */
+            value: string;
+        };
+    };
+    'v1.storage.string.set': {
+        params: {
+            key: string;
+            /** Auto-delete the key after this many seconds. Omit or 0 = no expiry. */
+            /** @format int64 */
+            ttl?: string;
+            value: string;
+        };
+        result: {
+            success: boolean;
+        };
+    };
+    /**
+     * Read a top counter: total sum in the window, last incrementer,
+     * top-N users by total, and per-day breakdown.
+     */
+    'v1.storage.top.get': {
+        params: {
+            key: string;
+            /** Sliding time horizon for summing increments. */
+            top: TV1TopWindow;
+            /** How many users to return in `topUsers`. 0 = default 10; max 100. */
+            topN?: number;
+        };
+        result: {
+            topUsers?: TV1TopUserEntry[];
+        };
+    };
+    /** Append an increment to a top counter for the current model session. */
+    'v1.storage.top.increment': {
+        params: {
+            /**
+             * Positive amount to add.
+             * @format int64
+             */
+            amount: string;
+            key: string;
+            /** An optional string saved for this increment from that user's latest event. */
+            meta?: string;
+            /**
+             * User id credited for this increment (appears in `top/get` top_users).
+             * @format int64
+             */
+            userId: string;
+        };
+        result: {
+            /** An optional string saved for this increment from that user's latest event. */
+            meta?: string;
+            success: boolean;
+            /** Echo of request `userId`; `windowStats` apply to this user. */
+            /** @format int64 */
+            userId?: string;
+            /** One entry per standard horizon (1d, 7d, 30d) with that user's total in each window after the increment. */
+            windowStats?: TV1TopIncrementWindowStat[];
+        };
+    };
+    /** Clear all increments for a top counter key. */
+    'v1.storage.top.reset': {
+        params: {
+            key: string;
+        };
+        result: {
+            success: boolean;
+        };
+    };
+};
+
+declare type TV1SystemMethods = {
+    'v1.system.report.crash': {
+        params: {
+            data?: Record<string, unknown>;
+            error?: TV1SerializedError;
+            kind: string;
+            type: 'network' | 'runtime';
+        };
+        result: null;
+    };
+    'v1.system.resize.notify': {
+        params: {
+            height: number;
+            width: number;
+        };
+        result: null;
+    };
+};
+
+/** Tokens spend tip data */
+declare type TV1TipData = {
+    /** Amount of tokens spent */
+    amount: number;
+    /** Tip id */
+    id: string;
+    /** Is anonymous tip or not */
+    isAnonymous: boolean;
+    /** Is tip sent from the current user or not */
+    isFromTheCurrentUser: boolean;
+    /** Is tip sent from the current extension or not */
+    isOriginalSource: boolean;
+    /** Message  that was sent with the tip. Empty string if no message was sent */
+    message?: string;
+    /** Source of the tip. Could be one of the following:
+     *
+     * `console` - tip was sent using / command
+     * `tipMenu` - tip was sent using tip menu
+     * `goal` - tip was sent via goal button
+     * `epicGoal` - tip was sent to epic goal
+     * `fullscreen` - tip was sent from the fullscreen view
+     * `interactiveToy` - tip was sent from the interactive toy
+     * `privateChat` - tip was sent from the private chat, in any type of show
+     * `publicChat` - tip was sent using publich chat, either in public or group show.
+     * `extension` - tip was sent from one of the extensions
+     * `sendTipButton` - tip was sent using send tip button
+     * `feed` - tip was sent from the feed
+     * */
+    source: TV1TipSource;
+    /** Message visibility: `public` — visible to everyone in the room; `private` — visible only to the model. */
+    type: 'private' | 'public';
+    /** User who sent the tip. Can be null in case of anonymous tip */
+    user?: TV1ExtUser | null;
+};
+
+declare type TV1TipEvents = {
+    /** Fired when the tip menu has been updated.*/
+    'v1.tipMenu.updated': {
+        /** The current tip menu data. */
+        tipMenu: TV1TipMenu;
+    };
+    /** Fired on every tip in chat for both model and user. Doesn't fire on private tips during public shows */
+    'v1.tokens.spent': {
+        tipData: TV1TipData;
+    };
+};
+
+/** Tip menu data */
+declare type TV1TipMenu = {
+    /** Whether tip menu is enabled or not. If it's disabled, the `items` array will be empty. */
+    isEnabled: boolean;
+    /** The list of tip menu items sorted by the model. */
+    items: TV1TipMenuItem[];
+};
+
+/** Tip menu item defined by the model. */
+declare type TV1TipMenuItem = {
+    /** Activity name */
+    activity: string;
+    /** Price of the activity for the current user applying all discounts.
+     *  Discounts can be applied based on the user's fan club memberhip.
+     * */
+    price: number;
+};
+
+declare type TV1TipMethods = {
+    /** Get the current tip menu. Tip menu data might change during the broadcast, so subscribe to `v1.tipMenu.updated` to listen to these changes. */
+    'v1.tipMenu.get': {
+        params: null;
+        result: {
+            /** The current tip menu data. */
+            tipMenu: TV1TipMenu;
+        };
+    };
+};
+
+/** Source of the tip. Could be one of the following:
+ *
+ * `console` - tip was sent using / command
+ * `tipMenu` - tip was sent using tip menu
+ * `goal` - tip was sent via goal button
+ * `epicGoal` - tip was sent to epic goal
+ * `fullscreen` - tip was sent from the fullscreen view
+ * `interactiveToy` - tip was sent from the interactive toy
+ * `privateChat` - tip was sent from the private chat, in any type of show
+ * `publicChat` - tip was sent using publich chat, either in public or group show.
+ * `extension` - tip was sent from one of the extensions
+ * `sendTipButton` - tip was sent using send tip button
+ * `feed` - tip was sent from the feed
+ */
+declare type TV1TipSource = 'console' | 'tipMenu' | 'goal' | 'epicGoal' | 'fullscreen' | 'interactiveToy' | 'publicChat' | 'privateChat' | 'extension' | 'sendTipButton' | 'feed';
+
+/** Custom data that you can pass when requesting token spend. You will receive it on successful payment */
+declare type TV1TokenSpendData = TUnknownDictionary;
+
+/**
+ * Per-window statistics for a user after a top counter increment.
+ * One entry per standard horizon (1d, 7d, 30d).
+ */
+declare type TV1TopIncrementWindowStat = {
+    /** User's summed total within this window after the increment. */
+    value: string;
+    /** Sliding time horizon (1d, 7d, or 30d). */
+    window: TV1TopWindow;
+};
+
+declare type TV1TopUserEntry = {
+    /** An optional string saved for this increment from that user's latest event */
+    meta?: string;
+    /** Sum of increment amounts within the sliding window for this user. */
+    total: string;
+    /** User ID recorded as incrementer. */
+    userId: string;
+};
+
+declare type TV1TopWindow = 'TOP_1D' | 'TOP_7D' | 'TOP_30D' | 'TOP_UNSPECIFIED';
+
+/**
+ * User activity league. Ordered from lowest to highest activity rank:
+ * - `grey` — new or low-activity users (level 1–9)
+ * - `bronze` — early active users (level 10–19)
+ * - `silver` — regularly active users (level 20–34)
+ * - `gold` — highly active users (level 35–54)
+ * - `diamond` — very highly active users (level 55–79)
+ * - `royal` — elite activity users (level 80–99)
+ * - `legend` — top activity users (level 100)
+ */
+declare type TV1UserLeague = 'grey' | 'bronze' | 'silver' | 'gold' | 'diamond' | 'royal' | 'legend';
+
+/** User activity ranking system */
+declare type TV1UserRanking = {
+    /** League representation of the user's activity level. Could be `grey`, `bronze`, `silver`, `gold`, `diamond`, `royal` or `legend`. */
+    league: TV1UserLeague;
+    /** Activity level from 1 to 100. */
+    level: number;
+};
+
+declare type TV1UsersFanClub = TV1UsersFanClubSubscribed | TV1UsersFanClubNotSubscribed;
+
+declare type TV1UsersFanClubNotSubscribed = {
+    /** Whether user is subscribed to the model's fan club or not */
+    isSubscribed: false;
+};
+
+declare type TV1UsersFanClubSubscribed = {
+    /** Whether user is subscribed to the model's fan club or not */
+    isSubscribed: true;
+    /** The tier of the fan club subscription. Could be `soldier`, `lord` or `prince`. Higher tiers provide more benefits. */
+    tier: TV1FanClubTier;
+};
+
+declare type TV1UserStatus = Exclude<(typeof V1_SHOW_STATUSES)[keyof typeof V1_SHOW_STATUSES], 'idle'>;
+
+declare type TV1WhisperData = TUnknownDictionary;
+
+declare const V1_SHOW_STATUSES: {
+    readonly STATUS_TICKET_SHOW: "ticketShow";
+    readonly STATUS_GROUP_SHOW: "groupShow";
+    readonly STATUS_OFF: "off";
+    readonly STATUS_PRIVATE: "private";
+    readonly STATUS_EXCLUSIVE_PRIVATE: "exclusivePrivate";
+    readonly STATUS_PUBLIC: "public";
+    readonly STATUS_IDLE: "idle";
+    readonly STATUS_SPY: "spy";
+};
+
+export { }