glitch-javascript-sdk 3.10.8 → 4.0.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AxiosPromise, AxiosProgressEvent } from 'axios';
+import { AxiosPromise, AxiosProgressEvent, AxiosRequestConfig } from 'axios';
 
 /**
  * Config
@@ -5916,7 +5916,10 @@ declare class Messages {
      */
     static listMessageThreads<T>(params?: Record<string, any>): AxiosPromise<Response<T>>;
     /**
-     * Send a new message that will be added to a thread
+     * Send a new message that will be added to a thread. Festival-scoped threads
+     * enforce current admission, blocking and read-only state server-side.
+     * Include an optional client_message_id UUID and reuse it when retrying a
+     * timed-out request to prevent duplicate messages and notifications.
      *
      * @see https://api.glitch.fun/api/documentation#/Messages/storeMessage
      *
@@ -11890,6 +11893,1219 @@ declare class GameDesign {
     static generateBlueprint<T = GameDesignBlueprint>(input: GameDesignBlueprintInput): AxiosPromise<Response<T>>;
 }
 
+type FestivalPostKind = 'discussion' | 'job' | 'talent';
+type FestivalPostState = 'active' | 'locked' | 'archived' | 'hidden' | 'deleted' | 'removed' | 'paused' | 'filled' | 'expired' | 'closed';
+type FestivalApplicationState = 'submitted' | 'viewed' | 'shortlisted' | 'interview' | 'accepted' | 'rejected' | 'withdrawn' | 'closed';
+type FestivalWorkType = 'full_time' | 'part_time' | 'contract' | 'gig';
+type FestivalRequestOptions = Pick<AxiosRequestConfig, 'signal' | 'timeout'>;
+interface FestivalNetworkingSettings {
+    discussions_enabled: boolean;
+    jobs_enabled: boolean;
+    employer_posts_enabled: boolean;
+    talent_posts_enabled: boolean;
+    matching_enabled: boolean;
+    voting_enabled: boolean;
+    comments_enabled: boolean;
+    media_enabled: boolean;
+    /** Registration or a valid ticket is mandatory; cannot be disabled. */
+    require_registration: true;
+    public_viewing: false;
+    anonymous_enabled: false;
+    categories: string[];
+    skills: string[];
+}
+interface FestivalPostInput {
+    kind: FestivalPostKind;
+    title: string;
+    /** Sanitized HTML from the shared WYSIWYG editor. */
+    content: string;
+    visibility?: 'public' | 'unlisted' | 'private';
+    category?: string | null;
+    tags?: string[];
+    skills?: string[];
+    preferred_skills?: string[];
+    job_types?: FestivalWorkType[];
+    company?: string | null;
+    organization_id?: string | null;
+    work_arrangement?: 'remote' | 'onsite' | 'hybrid' | null;
+    experience?: 'any' | 'entry' | 'junior' | 'mid' | 'senior' | 'lead' | null;
+    location?: string | null;
+    availability?: 'immediately' | 'within_30_days' | 'specific_date' | 'flexible' | 'unavailable';
+    availability_date?: string | null;
+    deadline?: string | null;
+    expires_at?: string | null;
+    compensation_type?: 'negotiable' | 'yearly' | 'monthly' | 'hourly' | 'flat_fee';
+    compensation_min?: number | null;
+    compensation_max?: number | null;
+    currency?: string | null;
+    portfolio_url?: string | null;
+    application_method?: 'internal' | 'external';
+    application_url?: string | null;
+    /** UserMedia IDs returned by uploadMedia, NOT Media IDs or clip-library selections. Max 8. */
+    media_ids?: string[];
+    public_compensation?: boolean;
+    public_location?: boolean;
+    public_availability?: boolean;
+    public_portfolio?: boolean;
+}
+interface FestivalNetworkingFilters {
+    kind?: FestivalPostKind;
+    view?: 'all' | 'mine' | 'saved' | 'hidden' | 'comments';
+    sort?: 'new' | 'hot' | 'top' | 'discussed' | 'compensation' | 'deadline';
+    window?: 'today' | 'week' | 'month' | 'festival' | 'all';
+    q?: string;
+    category?: string;
+    skill?: string;
+    job_type?: FestivalWorkType;
+    arrangement?: 'remote' | 'onsite' | 'hybrid';
+    experience?: string;
+    location?: string;
+    company?: string;
+    availability?: string;
+    currency?: string;
+    compensation_type?: string;
+    min_compensation?: number;
+    tag?: string;
+    author?: string;
+    has_comments?: boolean;
+    has_portfolio?: boolean;
+    media_type?: 'image' | 'video';
+    page?: number;
+    per_page?: number;
+}
+interface FestivalMediaUpload {
+    id: string;
+    user_media_id: string;
+    media_id: string;
+    url: string;
+    mime_type: string;
+    size: number;
+    title: string;
+    processing_status: 'completed' | 'pending' | 'processing' | 'failed';
+}
+interface FestivalNetworkingProfile {
+    id: string | null;
+    name: string;
+}
+interface FestivalNetworkingResponse<T> {
+    data: T;
+    message?: string;
+    meta?: {
+        current_page: number;
+        last_page: number;
+        total?: number;
+    };
+    has_access?: boolean;
+    can_manage?: boolean;
+    can_moderate?: boolean;
+    user?: FestivalNetworkingProfile | null;
+    show?: {
+        id: string;
+        name: string;
+    };
+    audit?: Array<Record<string, unknown>>;
+}
+interface FestivalPost {
+    id: string;
+    game_show_id: string;
+    parent_id: string | null;
+    kind: FestivalPostKind | 'comment';
+    title: string;
+    content: string;
+    state: FestivalPostState;
+    visibility: 'public' | 'unlisted' | 'private';
+    details: Partial<FestivalPostInput>;
+    author: FestivalNetworkingProfile | null;
+    created_at: string;
+    updated_at: string;
+    score: number;
+    my_vote: -1 | 0 | 1;
+    saved: boolean;
+    is_owner: boolean;
+    can_edit: boolean;
+    comment_count: number;
+    media: Array<{
+        id: string;
+        user_media_id?: string | null;
+        url: string;
+        mime_type: string;
+        title: string | null;
+    }>;
+    my_application?: {
+        id: string;
+        status: FestivalApplicationState;
+    } | null;
+    match?: {
+        score: number;
+        reasons: string[];
+        missing_required_skills: string[];
+        disclaimer: string;
+    };
+}
+interface FestivalApplicationInput {
+    message?: string;
+    portfolio?: string[];
+}
+interface FestivalConversation {
+    id: string;
+    festival_application_id: string;
+    can_send: boolean;
+    read_only_reason: string | null;
+    festival_context: {
+        game_show_id: string;
+        post_id: string | null;
+        title: string;
+        kind: FestivalPostKind;
+        application_status: FestivalApplicationState;
+    } | null;
+    users: Array<{
+        id: string | null;
+        display_name: string;
+        avatar: string | null;
+    }>;
+    messages: Array<{
+        id: string;
+        thread_id: string;
+        user_id: string | null;
+        message: string;
+        client_message_id: string | null;
+        created_at: string;
+        updated_at: string;
+        user: {
+            id: string | null;
+            display_name: string;
+            avatar: string | null;
+        };
+    }>;
+}
+interface FestivalPreferences {
+    notifications?: boolean;
+    blocked_users?: string[];
+    blocked_companies?: string[];
+}
+interface FestivalReportInput {
+    reason: 'spam' | 'harassment' | 'hate' | 'sexual_content' | 'scam' | 'job_scam' | 'copyright' | 'malicious_link' | 'misleading' | 'other';
+    explanation?: string;
+}
+/** Festival-scoped discussions, talent, jobs, moderation and new owned media uploads. */
+declare class FestivalNetworking {
+    private static request;
+    /** Read enabled tools and the current account's registration/ticket access. */
+    static settings<T = FestivalNetworkingSettings>(id: string, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Organizer-only settings update; admission remains mandatory. */
+    static updateSettings<T = FestivalNetworkingSettings>(id: string, data: Partial<FestivalNetworkingSettings>): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Search posts; compensation comparisons require currency and period. */
+    static listPosts<T = FestivalPost[]>(id: string, params?: FestivalNetworkingFilters, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Create a post with rich HTML and optional newly uploaded UserMedia IDs. */
+    static createPost<T = FestivalPost>(id: string, data: FestivalPostInput): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Direct links still require admission and content visibility permission. */
+    static getPost<T = FestivalPost>(id: string, post_id: string, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Edit or soft-delete via state; omit media_ids to preserve current attachments. */
+    static updatePost<T = FestivalPost>(id: string, post_id: string, data: Partial<FestivalPostInput> & {
+        state?: FestivalPostState;
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Paginated direct replies; fetch children to expand a thread. */
+    static listComments<T = FestivalPost[]>(id: string, post_id: string, params?: {
+        page?: number;
+    }, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Add a rich-text reply, subject to locking and five-level nesting. */
+    static createComment<T = FestivalPost>(id: string, post_id: string, data: {
+        content: string;
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Set, replace, or remove a vote/save/hide idempotently. */
+    static setInteraction<T = FestivalPost>(id: string, post_id: string, data: {
+        action: 'vote' | 'saved' | 'hidden';
+        value: -1 | 0 | 1;
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Apply or express interest once; the original listing is snapshotted. */
+    static apply<T = Record<string, unknown>>(id: string, post_id: string, data: FestivalApplicationInput): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Discovery matches for the current user's own job/talent listing. */
+    static matches<T = FestivalPost[]>(id: string, post_id: string, params?: {
+        page?: number;
+    }, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Report suspicious content privately to festival moderators. */
+    static report<T = never>(id: string, post_id: string, data: FestivalReportInput): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Only the applicant and listing owner receive application records. */
+    static applications<T = Array<Record<string, unknown>>>(id: string, params?: {
+        page?: number;
+    }, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Applicant withdrawal or owner-managed status changes. */
+    static updateApplication<T = Record<string, unknown>>(id: string, application_id: string, data: {
+        status: Exclude<FestivalApplicationState, 'submitted'>;
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Open the application/talent inquiry's private shared-inbox conversation, creating it once for legacy applications. Only the applicant and original listing owner may call this. Use Messages.getThread/sendMessage for subsequent conversation activity. */
+    static conversation<T = FestivalConversation>(id: string, application_id: string): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Moderator-only report queue and audit history. */
+    static moderation<T = Array<Record<string, unknown>>>(id: string, params?: {
+        page?: number;
+    }, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Moderation remains available even while the board is disabled. */
+    static moderatePost<T = FestivalPost>(id: string, post_id: string, data: {
+        state?: 'active' | 'hidden' | 'locked' | 'deleted' | 'removed';
+        remove_media?: true;
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Resolve, dismiss or begin reviewing a report. */
+    static resolveReport<T = never>(id: string, report_id: string, data: {
+        status: 'under_review' | 'resolved' | 'dismissed';
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Moderator-only participant restrictions. */
+    static restrictMember<T = never>(id: string, user_id: string, data: {
+        banned: boolean;
+    }): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Current user's privacy and notification preferences. */
+    static preferences<T = FestivalPreferences>(id: string, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Set notification opt-out and blocked participants/companies. */
+    static updatePreferences<T = FestivalPreferences>(id: string, data: FestivalPreferences): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Uploaded festival attachments only; not the gameplay clip library. */
+    static media<T = Array<Record<string, unknown>>>(id: string, params?: {
+        page?: number;
+    }, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /**
+     * Upload a new image (10 MB max) or video (100 MB max), using the existing media pipeline.
+     * The response ID is an owned UserMedia ID for createPost/updatePost media_ids.
+     * @param file New file selected by the attendee; supported images exclude SVG.
+     * @param data Which enabled board the upload is for.
+     * @param onUploadProgress Transfer progress; 100% may still require conversion before completion.
+     */
+    static uploadMedia<T = FestivalMediaUpload>(id: string, file: File | Blob, data: {
+        kind: FestivalPostKind;
+    }, onUploadProgress?: (event: AxiosProgressEvent) => void, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Organizations the authenticated user is authorized to represent. */
+    static organizations<T = Array<{
+        id: string;
+        name: string;
+    }>>(id: string, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+    /** Organizer-only aggregate participation metrics. */
+    static analytics<T = Record<string, unknown>>(id: string, options?: FestivalRequestOptions): AxiosPromise<FestivalNetworkingResponse<T>>;
+}
+
+type MicrotransactionEnvironment = 'sandbox' | 'live';
+type MicrotransactionProviderName = 'stripe' | 'xsolla';
+type MicrotransactionProductType = 'durable' | 'consumable' | 'currency' | 'bundle' | 'pass';
+type MicrotransactionCurrency = 'USD' | 'EUR' | 'GBP' | 'CAD' | 'AUD' | 'JPY' | 'BRL' | 'INR' | 'KRW';
+type MicrotransactionProductStatus = 'draft' | 'active' | 'archived';
+type MicrotransactionPaymentStatus = 'created' | 'action_required' | 'pending' | 'unknown' | 'paid' | 'failed' | 'canceled' | 'refund_pending' | 'partially_refunded' | 'refunded' | 'disputed' | 'quarantined' | 'refund_review';
+type MicrotransactionRefundStatus = 'requested' | 'linked' | 'unknown' | 'pending' | 'submitted' | 'succeeded' | 'failed' | 'canceled';
+type MicrotransactionDeliveryStatus = 'pending' | 'retrying' | 'processing' | 'acknowledged' | 'failed' | 'superseded';
+type MicrotransactionPayoutStatus = 'pending' | 'transferred' | 'bank_paid' | 'bank_pending' | 'bank_failed' | 'transfer_reversed';
+type MicrotransactionFulfillmentStatus = 'not_ready' | 'pending' | 'delivered' | 'retrying' | 'failed' | 'revoked' | 'partially_recovered';
+type MicrotransactionAbility = 'commerce:read' | 'commerce:write' | 'commerce:finance' | 'commerce:fulfill';
+type MicrotransactionErrorCode = 'authentication_required' | 'permission_denied' | 'not_found' | 'not_eligible' | 'quote_expired' | 'already_owned' | 'idempotency_conflict' | 'payment_unknown' | 'rate_limited' | 'invalid_revenue_configuration' | 'fulfillment_pending' | 'provider_unavailable';
+/** The backend's JSON envelope; Axios returns this envelope in response.data. */
+interface MicrotransactionResponse<T> {
+    data: T;
+    message?: string;
+    success?: boolean;
+}
+interface MicrotransactionError {
+    message: string;
+    code?: MicrotransactionErrorCode | string;
+    errors?: Record<string, string[]>;
+}
+interface MicrotransactionRequestOptions extends Pick<AxiosRequestConfig, 'signal' | 'timeout'> {
+    /** Optional short-lived commerce-only player token. Never a shipped developer/title token. */
+    playerToken?: string;
+}
+interface MicrotransactionSessionOptions extends MicrotransactionRequestOptions {
+    /** Required limited checkout capability; sent only in X-Checkout-Token, never a query. */
+    checkoutToken: string;
+}
+interface MicrotransactionEnvironmentFilter {
+    environment?: MicrotransactionEnvironment;
+}
+/** Catalog discovery defaults to 200 records per page; absence on page one is not proof a SKU is unused. */
+interface MicrotransactionProductListFilters {
+    page?: number;
+    per_page?: number;
+    status?: MicrotransactionProductStatus;
+    /** Exact SKU, not a substring search. */
+    sku?: string;
+}
+/** Administrative lists default to page 1 / 25 records and are scoped to the authorized title. */
+interface MicrotransactionManagementListFilters extends MicrotransactionEnvironmentFilter {
+    page?: number;
+    per_page?: number;
+    status?: string;
+}
+interface MicrotransactionOrderListFilters extends MicrotransactionManagementListFilters {
+    product_id?: string;
+    status?: MicrotransactionPaymentStatus;
+    payment_status?: MicrotransactionPaymentStatus;
+}
+interface MicrotransactionRelatedListFilters extends MicrotransactionManagementListFilters {
+    order_id?: string;
+}
+interface MicrotransactionRefundListFilters extends MicrotransactionRelatedListFilters {
+    status?: MicrotransactionRefundStatus;
+}
+interface MicrotransactionDeliveryListFilters extends MicrotransactionRelatedListFilters {
+    status?: MicrotransactionDeliveryStatus;
+}
+interface MicrotransactionPayoutListFilters extends MicrotransactionRelatedListFilters {
+    status?: MicrotransactionPayoutStatus;
+}
+/** @deprecated Optional compatibility field only; no confirmation or human-approval gate is enforced. */
+interface MicrotransactionLegacyConfirmation {
+    confirm?: boolean;
+}
+/** Self-only purchase-history filters. Identity comes from authentication, never a user_id argument. */
+interface MicrotransactionMyPurchasesFilters extends MicrotransactionEnvironmentFilter {
+    /** Page number, integer 1–10000. Defaults to 1; ordering is created_at DESC, id DESC. */
+    page?: number;
+    /** Integer 1–100. Defaults to 20. No cursor or product filter is supported. */
+    per_page?: number;
+}
+interface MicrotransactionCatalogFilter extends MicrotransactionEnvironmentFilter {
+    country?: string;
+    currency?: string;
+    channel?: 'web';
+}
+interface MicrotransactionMedia {
+    id: string;
+    url: string;
+    mime_type: string;
+    poster?: string | null;
+}
+interface MicrotransactionBranding {
+    display_name?: string | null;
+    accent_color?: string | null;
+    /** Existing authorized title Media ID, not an external URL or UserMedia ID. */
+    logo_media_id?: string | null;
+    /** Resolved public Media returned for display; not a writable branding input. */
+    logo_media?: MicrotransactionMedia | null;
+}
+interface MicrotransactionPrice {
+    /** Uppercase ISO 4217 currency. Not all currencies have two decimal places. */
+    currency: MicrotransactionCurrency;
+    /** Uppercase ISO 3166-1 alpha-2 buyer country, or '*' default. */
+    country: string;
+    /** Integer 1–100000 in currency minor units: USD 499 means $4.99; JPY 499 means ¥499. Provider minima apply separately. */
+    amount_minor: number;
+}
+interface MicrotransactionGrant {
+    /** Stable per-title inventory key; never a client-supplied grant at checkout. */
+    key: string;
+    quantity: number;
+    kind: 'durable' | 'consumable' | 'pass';
+    /** Required for pass grants; 60–31536000 seconds. Durable quantity must be one. */
+    duration_seconds?: number | null;
+}
+interface MicrotransactionProductInput {
+    sku: string;
+    name: string;
+    description?: string;
+    type: MicrotransactionProductType;
+    status?: MicrotransactionProductStatus;
+    /** Attach IDs from the existing title-authorized Media pipeline. No arbitrary media URLs. */
+    media_ids?: string[];
+    prices: MicrotransactionPrice[];
+    grants: MicrotransactionGrant[];
+    localizations?: Record<string, {
+        name: string;
+        description?: string | null;
+    }>;
+    starts_at?: string | null;
+    ends_at?: string | null;
+    max_per_order?: number;
+    /** @deprecated Ignored compatibility field. Title authorization and immutable-data validation remain required. */
+    confirm?: boolean;
+}
+interface MicrotransactionProduct extends Omit<MicrotransactionProductInput, 'confirm' | 'status' | 'media_ids'> {
+    id: string;
+    title_id: string;
+    status: MicrotransactionProductStatus;
+    version: number;
+    media_ids: string[];
+    media: MicrotransactionMedia[];
+    created_at: string;
+    updated_at: string;
+}
+interface MicrotransactionProvider {
+    provider: MicrotransactionProviderName;
+    environment: MicrotransactionEnvironment;
+    configured: boolean;
+    /** Actual external provider/account capability, not a manual approval flag. */
+    available: boolean;
+    enabled: boolean;
+    priority: number;
+    countries: string[];
+    currencies: string[];
+    minimum_amounts: Record<string, number>;
+    channels: string[];
+    payment_methods: string[];
+    configuration: MicrotransactionProviderConfiguration;
+    account: {
+        id: string;
+        country: string | null;
+        charges_enabled: boolean;
+        payouts_enabled: boolean;
+        requirements_due: string[];
+    } | null;
+    /** The game's payout target. Do not substitute the platform processing account's payouts_enabled. */
+    payout_account: {
+        source: 'platform' | 'user' | 'community' | 'managed';
+        id: string | null;
+        available: boolean;
+        country: string | null;
+        transfers_active: boolean;
+        payouts_enabled: boolean;
+        requirements_due: string[];
+        reasons: string[];
+    };
+    tax: {
+        status: string;
+        missing_fields: string[];
+    };
+    reasons: string[];
+    checked_at: string | null;
+    revision?: number;
+}
+interface MicrotransactionProviderSku {
+    /** Provider SKU, 1–100 characters. */
+    sku: string;
+    currency: MicrotransactionCurrency;
+    amount_minor: number;
+}
+interface MicrotransactionProviderConfiguration {
+    tax_mode: 'automatic' | 'disabled';
+    /** Stripe tax code txcd_ followed by exactly eight digits. */
+    tax_code: string | null;
+    payout_source: 'platform' | 'user' | 'community' | 'managed';
+    /** Xsolla public project ID, 1–20 decimal digits. */
+    project_id: string | null;
+    /** Maximum 200 mappings. */
+    sku_map: Record<string, MicrotransactionProviderSku>;
+}
+/** Developer preferences and an optional new owned Xsolla webhook secret only; never platform credentials, arbitrary payees, or availability facts. */
+interface MicrotransactionProviderInput extends Partial<MicrotransactionProviderConfiguration>, MicrotransactionLegacyConfirmation {
+    environment: MicrotransactionEnvironment;
+    enabled?: boolean;
+    priority?: number;
+    countries?: string[];
+    currencies?: MicrotransactionCurrency[];
+    minimum_amounts?: Record<string, number>;
+    /** Write-only NEW owned Xsolla project secret, 16–512 chars, finance scope. Never a platform API key or MCP token; never returned/logged or put in game code. Existing platform/historical bindings cannot be overwritten. */
+    webhook_secret?: string;
+}
+interface MicrotransactionProviderOnboardingInput extends MicrotransactionLegacyConfirmation {
+    environment: MicrotransactionEnvironment;
+    country: string;
+    /** Stable caller-created key. Reuse with identical input after uncertain retries; never generate inside a retry. */
+    idempotency_key: string;
+}
+interface MicrotransactionProviderOnboarding {
+    title_id: string;
+    provider: 'stripe';
+    environment: MicrotransactionEnvironment;
+    account_id: string;
+    /** Single-use provider onboarding URL on connect.stripe.com; do not log or persist it. */
+    onboarding_url: string;
+    expires_at: string;
+    status: 'requires_provider_onboarding';
+    reused: boolean;
+}
+interface MicrotransactionDeliverySettings {
+    title_id: string;
+    environment: MicrotransactionEnvironment;
+    enabled: boolean;
+    url: string | null;
+    signature_algorithm: 'ed25519' | 'hmac-sha256';
+    /** Public verification material only. The private signing key never leaves the server. */
+    verification_public_key: string | null;
+    key_id: string | null;
+    revision: number;
+    configured: boolean;
+}
+interface MicrotransactionDeliverySettingsInput extends MicrotransactionLegacyConfirmation {
+    environment: MicrotransactionEnvironment;
+    enabled?: boolean;
+    url?: string | null;
+}
+interface MicrotransactionDelivery {
+    id: string;
+    order_id: string;
+    event_type: string;
+    status: MicrotransactionDeliveryStatus;
+    attempts: number;
+    next_attempt_at: string | null;
+    acknowledged_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** Replay/acknowledgement return only this safe subset, not the list's timestamps. */
+type MicrotransactionDeliveryResult = Pick<MicrotransactionDelivery, 'id' | 'order_id' | 'status' | 'event_type' | 'attempts' | 'acknowledged_at'>;
+interface MicrotransactionRefundRecord {
+    id: string;
+    order_id: string;
+    status: MicrotransactionRefundStatus;
+    amount_minor: number;
+    reason: string;
+    idempotency_key: string | null;
+    record_type: 'request' | 'execution';
+    execution_refund_id: string | null;
+    execution_status: MicrotransactionRefundStatus | null;
+    request_resolution: 'linked_to_execution' | 'not_executed' | null;
+    order_refunded_minor: number | null;
+    failure_code: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface MicrotransactionPayout {
+    id: string;
+    order_id: string;
+    status: MicrotransactionPayoutStatus;
+    amount_minor: number;
+    provider_reference: string | null;
+    created_at: string;
+    updated_at: string;
+}
+interface MicrotransactionRefundInput extends MicrotransactionLegacyConfirmation {
+    reason: string;
+    amount_minor?: number;
+    /** REQUIRED stable operation key, scoped to title/order. Reuse identical input on retry; changes conflict. */
+    idempotency_key: string;
+}
+interface MicrotransactionReadiness {
+    status: 'disabled' | 'draft' | 'sandbox' | 'ready' | 'live' | 'degraded' | 'suspended';
+    ready: boolean;
+    blockers: string[];
+    providers: MicrotransactionProvider[];
+    commission_basis_points: 1200;
+}
+interface MicrotransactionFramePolicy {
+    frame_ancestors: string[];
+    expires_at: string | null;
+}
+interface MicrotransactionSettingsInput {
+    enabled?: boolean;
+    environment?: MicrotransactionEnvironment;
+    /** Actual title-wide ad-delivery policy, distinct from ad revenue sharing. */
+    ads_enabled?: boolean;
+    fulfillment_mode?: 'glitch' | 'server';
+    allowed_origins?: string[];
+    countries?: string[];
+    currencies?: MicrotransactionCurrency[];
+    branding?: Omit<MicrotransactionBranding, 'logo_media'>;
+    support_email?: string | null;
+    /** @deprecated Legacy delivery alias requiring BOTH commerce:write and commerce:fulfill; prefer updateDeliverySettings/getDeliverySettings. */
+    webhook_url?: string | null;
+    /** @deprecated Ignored compatibility field. Authorized title editors save directly; actual provider/sales restrictions remain. */
+    confirm?: boolean;
+}
+interface MicrotransactionSettings extends Omit<Required<MicrotransactionSettingsInput>, 'confirm'> {
+    title_id: string;
+    branding: MicrotransactionBranding;
+    integration_verified: boolean;
+    /** 12% of discounted pre-tax subtotal; no second commission for in-game currency spending. */
+    commission_basis_points: 1200;
+    fee_policy: 'developer_pays_provider_costs';
+    readiness: MicrotransactionReadiness;
+}
+interface MicrotransactionCatalog {
+    title: {
+        id: string;
+        name: string;
+    };
+    branding: MicrotransactionBranding;
+    products: MicrotransactionProduct[];
+    environment: MicrotransactionEnvironment;
+    available: boolean;
+    blockers: string[];
+}
+interface MicrotransactionPurchaseInput {
+    product_id: string;
+    quantity: number;
+    country: string;
+    currency: string;
+    environment: MicrotransactionEnvironment;
+    channel: 'web';
+}
+interface MicrotransactionCheckoutSessionInput extends MicrotransactionPurchaseInput {
+    /** Exact game origin previously allowlisted by its owner. */
+    return_origin: string;
+    /** Random per-purchase state; retain locally and compare before claiming a handoff. */
+    nonce: string;
+}
+interface MicrotransactionQuote extends Omit<MicrotransactionPurchaseInput, 'channel'> {
+    id: string;
+    product_version: number;
+    subtotal_minor: number;
+    tax_minor: number;
+    total_minor: number;
+    commission_minor: number;
+    commission_basis_points: 1200;
+    expires_at: string;
+}
+interface MicrotransactionEntitlement {
+    key: string;
+    kind: 'durable' | 'consumable' | 'pass';
+    balance: number;
+    environment: MicrotransactionEnvironment;
+    updated_at: string;
+    expires_at?: string | null;
+}
+interface MicrotransactionOrder {
+    id: string;
+    /** Opaque owning Glitch player ID; no email or billing identity is exposed. */
+    player_id?: string;
+    checkout_session_id: string | null;
+    title_id: string;
+    product_id: string;
+    quantity: number;
+    environment: MicrotransactionEnvironment;
+    currency: string;
+    country: string;
+    subtotal_minor: number;
+    tax_minor: number;
+    total_minor: number;
+    commission_minor: number;
+    /** Null until actual costs are reconciled; never confuse an estimate with a payout. */
+    provider_fee_minor: number | null;
+    payment_status: MicrotransactionPaymentStatus;
+    fulfillment_status: MicrotransactionFulfillmentStatus;
+    provider: 'stripe' | 'xsolla' | null;
+    created_at: string;
+    paid_at: string | null;
+    refunded_minor: number;
+    items: MicrotransactionGrant[];
+    entitlements?: MicrotransactionEntitlement[];
+}
+interface MicrotransactionOrderDetail extends MicrotransactionOrder {
+    /** Optional, permission-scoped management relationships. Omission is not proof no records exist. */
+    refunds?: Array<Pick<MicrotransactionRefundRecord, 'id' | 'order_id' | 'status'> & Partial<MicrotransactionRefundRecord>>;
+    deliveries?: MicrotransactionDelivery[];
+    payouts?: Array<Pick<MicrotransactionPayout, 'id' | 'order_id' | 'status'> & Partial<MicrotransactionPayout>>;
+    financial_details_included?: boolean;
+}
+type MicrotransactionGrantUsageStatus = 'unused' | 'partially_used' | 'used_up' | 'owned' | 'expired' | 'revoked' | 'not_delivered' | 'unavailable';
+/** One purchase's server-calculated grant lot, not the player's aggregate inventory balance. */
+interface MicrotransactionGrantUsage {
+    /** Null when the captured purchase has not produced an actual grant lot. */
+    grant_id: string | null;
+    key: string;
+    kind: 'durable' | 'consumable' | 'pass';
+    /** Promised units from the frozen grant quantity multiplied by order quantity, not money. */
+    purchased_quantity: number;
+    /** Actual granted units; zero when no lot exists, even if promised units are positive. */
+    granted_quantity: number;
+    /** Alias of actual granted_quantity, not the promised purchased_quantity. */
+    acquired_quantity: number;
+    /** Units remaining in the lot; expired/unavailable lots may still have raw remaining units. */
+    remaining_quantity: number;
+    /** acquired_quantity - remaining_quantity - revoked_quantity. Includes unrecoverable consumed units. */
+    consumed_quantity: number;
+    /** Units actually recovered/revoked by a refund; not gameplay consumption. */
+    revoked_quantity: number;
+    /** Bounded revoked_quantity + unrecoverable_quantity. This overlaps consumed quantity; do not subtract twice. */
+    refunded_quantity: number;
+    /** Refunded units that could not be recovered because already consumed. Overlaps consumed_quantity. */
+    unrecoverable_quantity: number;
+    expires_at: string | null;
+    expired: boolean;
+    /** Server-calculated usable units after expiry and payment/fulfillment restrictions. */
+    usable_quantity: number;
+    /** Consumable usage only. Durable/pass grants return null; ownership is not proof of gameplay use. */
+    is_used: boolean | null;
+    usage_status: MicrotransactionGrantUsageStatus;
+}
+interface MicrotransactionPlayerPurchase extends MicrotransactionOrder {
+    /** Always present on authenticated self-history, unlike older generic order DTOs. */
+    player_id: string;
+    /** Product snapshot for this purchase, not a replacement for the current catalog. */
+    product: {
+        id: string;
+        sku: string | null;
+        name: string | null;
+        type: MicrotransactionProductType | null;
+        version: number | null;
+    };
+    grant_usage: MicrotransactionGrantUsage[];
+    has_consumed_grants: boolean;
+    has_usable_grants: boolean;
+}
+interface MicrotransactionPurchasePagination {
+    page: number;
+    per_page: number;
+    total: number;
+    last_page: number;
+    has_more_pages: boolean;
+}
+/** Captured own-player purchases, including later refunds/disputes/quarantine; unpaid attempts are excluded. */
+interface MicrotransactionMyPurchases {
+    title_id: string;
+    player_id: string;
+    environment: MicrotransactionEnvironment;
+    purchases: MicrotransactionPlayerPurchase[];
+    pagination: MicrotransactionPurchasePagination;
+}
+interface MicrotransactionCreatedCheckoutSession {
+    id: string;
+    checkout_session_id: string;
+    intent: 'purchase' | 'restore';
+    /** Short-lived capability: never log, send to analytics, or put in a URL query. */
+    session_token: string;
+    hosted_url: string;
+    expires_at: string;
+    status: 'authentication_required' | 'ready';
+    nonce: string;
+}
+interface MicrotransactionCheckoutSession {
+    id: string;
+    checkout_session_id: string;
+    title_id: string;
+    intent: 'purchase' | 'restore';
+    title: {
+        id: string;
+        name: string;
+    };
+    branding: MicrotransactionBranding;
+    product: MicrotransactionProduct | null;
+    quantity: number;
+    country: string;
+    currency: string;
+    environment: MicrotransactionEnvironment;
+    status: string;
+    expires_at: string;
+    authenticated: boolean;
+    order: MicrotransactionOrder | null;
+    return_origin: string;
+    nonce: string;
+    support_email: string | null;
+}
+interface MicrotransactionCheckoutInput {
+    /** UUID retained for retries of the same purchase, never reused for different goods. */
+    idempotency_key: string;
+    accept_terms: true;
+}
+interface MicrotransactionCheckoutResult {
+    order: MicrotransactionOrder;
+    checkout_url: string | null;
+    status: MicrotransactionPaymentStatus;
+    provider: 'stripe' | 'xsolla';
+    quote: MicrotransactionQuote;
+    /** Provider's limited embedded-checkout secret if this route supports embedded checkout. */
+    client_secret?: string | null;
+    /** Public provider key only. Never a Stripe secret key. */
+    publishable_key?: string | null;
+    ui_mode: 'embedded' | 'xsolla';
+}
+interface MicrotransactionHandoff {
+    event: {
+        type: 'glitch.microtransaction.updated';
+        version: 1;
+        title_id: string;
+        checkout_session_id: string;
+        order_id: string;
+        nonce: string;
+        /** One-time claim only; never an account JWT. */
+        claim_code: string;
+    };
+    target_origin: string;
+    expires_at: string;
+}
+interface MicrotransactionHandoffClaimInput {
+    claim_code: string;
+    nonce: string;
+    return_origin: string;
+    checkout_session_id: string;
+}
+interface MicrotransactionHandoffClaim {
+    title_id: string;
+    checkout_session_id: string;
+    order_id: string;
+    player_id: string;
+    entitlements: MicrotransactionEntitlement[];
+    /** 15-minute title/player/environment-scoped token, stored in memory only. */
+    player_token: string;
+    expires_at: string;
+}
+interface MicrotransactionConsumeInput {
+    key: string;
+    quantity: number;
+    action_id: string;
+    environment: MicrotransactionEnvironment;
+}
+interface MicrotransactionRefund {
+    refund_id: string;
+    status: MicrotransactionRefundStatus;
+    order_id: string;
+    idempotency_key: string;
+    failure_code: string | null;
+    refund_allocation?: 'pro_rata_all_grants';
+}
+interface MicrotransactionRefundRequest {
+    id: string;
+    order_id: string;
+    status: 'requested';
+}
+interface MicrotransactionEarnings {
+    currency_balances: Array<{
+        currency: string;
+        pending_minor: number;
+        available_minor: number;
+        paid_minor: number;
+        commission_minor: number;
+        provider_fees_minor: number;
+        /** Transfer to a connected provider balance is NOT a confirmed bank payout. */
+        transferred_minor?: number;
+        bank_payout_status?: 'provider_managed_not_reconciled';
+    }>;
+    payouts_enabled: boolean;
+    reserve_days?: number;
+}
+type MicrotransactionOperation = 'settings.get' | 'settings.update' | 'products.list' | 'products.create' | 'products.update' | 'products.archive' | 'providers.list' | 'providers.update' | 'providers.refresh' | 'providers.onboarding' | 'readiness.get' | 'orders.list' | 'orders.get' | 'orders.reconcile' | 'earnings.get' | 'refunds.list' | 'refunds.get' | 'refunds.create' | 'refunds.request' | 'refunds.reconcile' | 'delivery.settings.get' | 'delivery.settings.update' | 'deliveries.list' | 'deliveries.replay' | 'deliveries.acknowledge' | 'payouts.list' | 'integration.get' | 'integration.verify';
+interface MicrotransactionOperationCapability {
+    operation: MicrotransactionOperation;
+    description: string;
+    ability: MicrotransactionAbility;
+    input_schema: Record<string, unknown>;
+    http_method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    mutates: boolean;
+    requires_confirmation: false;
+    requires_human_approval: false;
+    examples: Array<Record<string, unknown>>;
+    output_description: string;
+}
+interface MicrotransactionCapabilities {
+    schema_version: number;
+    title_id: string;
+    operations: MicrotransactionOperationCapability[];
+    [key: string]: unknown;
+}
+/**
+ * Provider-neutral, title-scoped commerce. Configure with user JWT; purchases
+ * use a recoverable user account and limited checkout capability. Install/title
+ * tokens cannot authorize money, ownership, refunds, or catalog changes.
+ *
+ * Each result preserves payment versus fulfillment versus settlement. Redirects
+ * and postMessage events only trigger an authoritative refresh. A timeout is
+ * unknown; reconcile the original attempt instead of charging another provider.
+ */
+declare class Microtransactions {
+    /**
+     * Upload an image/video through existing Glitch Media processing with title
+     * and actor ownership. Attach its returned Media ID to products/branding.
+     * Does not create a social-library post, scheduler, or new payment product.
+     */
+    static uploadMedia(title_id: string, media: File | Blob, onUploadProgress?: (event: AxiosProgressEvent) => void, options?: Pick<AxiosRequestConfig, 'signal' | 'timeout'>): AxiosPromise<MicrotransactionResponse<MicrotransactionMedia>>;
+    /** Same title-authorized Media pipeline using the caller's MCP credential and commerce:write ability. */
+    static mcpUploadMedia(title_id: string, media: File | Blob, onUploadProgress?: (event: AxiosProgressEvent) => void, options?: Pick<AxiosRequestConfig, 'signal' | 'timeout'>): AxiosPromise<MicrotransactionResponse<MicrotransactionMedia>>;
+    /** Admin settings, including immutable 1200bp commission and readiness blockers. */
+    static settings(title_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionSettings>>;
+    /** Atomic policy update. Sandbox/off by default. Cannot disable the final working revenue model. */
+    static updateSettings(title_id: string, data: MicrotransactionSettingsInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionSettings>>;
+    /** Read-only current country/provider capability and revenue readiness; never fabricates availability. */
+    static readiness(title_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionReadiness>>;
+    /** Paginated admin catalog including drafts/archives. Default 200, per_page 1–200/page 1–10000. Use exact sku to resolve uncertain creates. */
+    static listProducts(title_id: string, params?: MicrotransactionProductListFilters, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        products: MicrotransactionProduct[];
+        pagination: MicrotransactionPurchasePagination;
+    }>>;
+    /** @deprecated Compatibility overload for the earlier second-argument request options. */
+    static listProducts(title_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        products: MicrotransactionProduct[];
+        pagination: MicrotransactionPurchasePagination;
+    }>>;
+    /** Save a catalog product. Prices use integer minor units and attached media must belong to the title. */
+    static createProduct(title_id: string, data: MicrotransactionProductInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionProduct>>;
+    /** Update a product version. Existing order snapshots remain unchanged. */
+    static updateProduct(title_id: string, product_id: string, data: Partial<MicrotransactionProductInput>, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionProduct>>;
+    /** Direct authorized archive. Never deletes financial history or bypasses the last-revenue-model rule. */
+    static archiveProduct(title_id: string, product_id: string, data?: MicrotransactionLegacyConfirmation, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionProduct>>;
+    /** Actual provider configuration/capability facts; no credentials or manual approval flag. */
+    static providers(title_id: string, params?: MicrotransactionEnvironmentFilter, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        providers: MicrotransactionProvider[];
+    }>>;
+    /** @deprecated Compatibility overload for the earlier second-argument request options. */
+    static providers(title_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        providers: MicrotransactionProvider[];
+    }>>;
+    /** Direct commerce:finance configuration. Saving preferences does not fabricate external capability; inspect available/reasons. */
+    static updateProvider(title_id: string, provider: MicrotransactionProviderName, data: MicrotransactionProviderInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionProvider>>;
+    /** Refresh authenticated external provider facts. May update cached state; never creates a payment or invents eligibility. */
+    static refreshProvider(title_id: string, provider: MicrotransactionProviderName, data: {
+        environment: MicrotransactionEnvironment;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionProvider>>;
+    /** Start/reuse owned Stripe Connect onboarding with one stable key. Provider KYC is factual setup, not a Glitch approval workflow. */
+    static createProviderOnboarding(title_id: string, data: MicrotransactionProviderOnboardingInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionProviderOnboarding>>;
+    /** Read title/environment delivery settings and the Ed25519 PUBLIC verification key. */
+    static getDeliverySettings(title_id: string, params?: MicrotransactionEnvironmentFilter, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionDeliverySettings>>;
+    /** Direct commerce:fulfill setup. Private/metadata network targets and private-key inputs remain forbidden. */
+    static updateDeliverySettings(title_id: string, data: MicrotransactionDeliverySettingsInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionDeliverySettings>>;
+    /** Discover safe event IDs/statuses before replay or acknowledge. Page 1–10000, per_page 1–100, default 25. */
+    static listDeliveries(title_id: string, params?: MicrotransactionDeliveryListFilters, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        deliveries: MicrotransactionDelivery[];
+        pagination: MicrotransactionPurchasePagination;
+    }>>;
+    /** Financially scoped refund operation discovery; pending/unknown is not completed. */
+    static listRefunds(title_id: string, params?: MicrotransactionRefundListFilters, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        refunds: MicrotransactionRefundRecord[];
+        pagination: MicrotransactionPurchasePagination;
+    }>>;
+    /** Inspect one same-title refund operation. */
+    static getRefund(title_id: string, refund_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionRefundRecord>>;
+    /** Query/retry the original persisted refund with its existing identity, never generate a new refund key. */
+    static reconcileRefund(title_id: string, refund_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionRefundRecord>>;
+    /** Discover provider transfer/payout records; transferred funds are not automatically a verified bank payout. */
+    static listPayouts(title_id: string, params?: MicrotransactionPayoutListFilters, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        payouts: MicrotransactionPayout[];
+        pagination: MicrotransactionPurchasePagination;
+    }>>;
+    /** Admin read of separate-currency balances; pending is not withdrawable revenue. */
+    static earnings(title_id: string, params?: MicrotransactionEnvironmentFilter, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionEarnings>>;
+    /** Admin paginated redacted orders. Page 1–10000/per_page 1–100 (default 25); own-player history is separate. */
+    static listOrders(title_id: string, params?: MicrotransactionOrderListFilters, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        orders: MicrotransactionOrder[];
+        pagination: MicrotransactionPurchasePagination;
+    }>>;
+    /** Owner JWT/scoped player token or title admin. An arbitrary order UUID grants no access. */
+    static getOrder(title_id: string, order_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionOrderDetail>>;
+    /** Financially scoped original-provider reconciliation. Does not reroute or start a different purchase. */
+    static reconcileOrder(title_id: string, order_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionOrderDetail>>;
+    /** Direct commerce:finance refund. REQUIRED stable idempotency_key; omission is an error, never auto-filled. Same-key changed input conflicts. */
+    static refundOrder(title_id: string, order_id: string, data: MicrotransactionRefundInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionRefund>>;
+    /** Replay the same immutable event. Receiver must deduplicate event_id. This cannot mint goods. */
+    static replayDelivery(title_id: string, delivery_id: string, data?: MicrotransactionLegacyConfirmation, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionDeliveryResult>>;
+    /** Public eligible catalog. Sandbox is restricted by backend environment/admin policy. */
+    static catalog(title_id: string, params?: MicrotransactionCatalogFilter, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCatalog>>;
+    /** User-authenticated quote. Clients select product/quantity, never monetary values or seller accounts. */
+    static createQuote(title_id: string, data: MicrotransactionPurchaseInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionQuote>>;
+    /** Anonymous-safe opening step only. The hosted UI creates/logs into an account before payment. */
+    static createCheckoutSession(title_id: string, data: MicrotransactionCheckoutSessionInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCreatedCheckoutSession>>;
+    /** Anonymous-safe inventory recovery. Opens an in-game hosted sign-in overlay, never creates a charge or requires the game's account JWT. */
+    static createRestoreSession(title_id: string, data: {
+        return_origin: string;
+        nonce: string;
+        environment: MicrotransactionEnvironment;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCreatedCheckoutSession>>;
+    /** Read the session using its limited capability. Cannot mutate user identity or declare payment. */
+    static getCheckoutSession(title_id: string, session_id: string, options: MicrotransactionSessionOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCheckoutSession>>;
+    /** Anonymous, read-only embedding policy: server-approved frame ancestors only, no player/session capability data. */
+    static getCheckoutFramePolicy(title_id: string, session_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionFramePolicy>>;
+    /** Anonymous title-wide approved embedding policy for trusted hosted account pages; no player data. */
+    static getFramePolicy(title_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionFramePolicy>>;
+    /** Bind once to the existing authenticated account. Cannot reassign another player's purchase. */
+    static authenticateCheckoutSession(title_id: string, session_id: string, options: MicrotransactionSessionOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCheckoutSession>>;
+    /** Bound-user JWT + session capability. Reuse the idempotency key after a network timeout. */
+    static checkout(title_id: string, session_id: string, data: MicrotransactionCheckoutInput, options: MicrotransactionSessionOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCheckoutResult>>;
+    /** Query original provider; never creates another charge. Pending/unknown remains non-terminal. */
+    static reconcileCheckoutSession(title_id: string, session_id: string, options: MicrotransactionSessionOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionOrder>>;
+    /** Hosted checkout only. Server issues an expiring one-time game handoff after verified fulfillment. */
+    static createHandoff(title_id: string, session_id: string, options: MicrotransactionSessionOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionHandoff>>;
+    /** Game exchanges a verified popup code. Browser Origin must match return_origin; code is consumed once. */
+    static claimHandoff(title_id: string, data: MicrotransactionHandoffClaimInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionHandoffClaim>>;
+    /**
+     * Authenticated hosted Glitch account only: restore a previous purchase into a
+     * NEW nonce-bound session/handoff after the game's 15-minute token expires or
+     * storage is cleared. Does not create another payment. Return to the game via
+     * verified source/origin and a new bridge bound to event.checkout_session_id.
+     */
+    static restoreHandoff(title_id: string, data: {
+        order_id: string;
+        return_origin: string;
+        nonce: string;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionHandoff>>;
+    /** Record integration proof from a genuinely paid, fulfilled sandbox order with a claimed game handoff. */
+    static verifyIntegration(title_id: string, data: {
+        order_id: string;
+        confirm?: boolean;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionReadiness>>;
+    /** Restore authoritative durable ownership/current consumable balances, never mutable cloud-save balances. */
+    static listEntitlements(title_id: string, params?: MicrotransactionEnvironmentFilter, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        entitlements: MicrotransactionEntitlement[];
+    }>>;
+    /**
+     * Optional self-only purchase/usage history. A user JWT selects that user; a
+     * scoped playerToken selects its bound title/player/environment and requires
+     * the exact approved game Origin. No MCP/install token or caller-selected
+     * user_id/player_id is accepted. JWT environment defaults to live; scoped
+     * tokens default to their bound environment. Admin listOrders stays separate.
+     *
+     * Read response.data.data.purchases and .pagination. Use grant_usage for lot
+     * consumption/refund/expiry status, listEntitlements for current aggregate
+     * inventory, and consume for explicit gameplay spending. History never grants
+     * inventory and durable/pass is_used is null rather than a guessed boolean.
+     */
+    static listMyPurchases(title_id: string, filters?: MicrotransactionMyPurchasesFilters, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionMyPurchases>>;
+    /** Atomic tracked spending. Reuse action_id for retries; a new gameplay action needs a new ID. */
+    static consume(title_id: string, data: MicrotransactionConsumeInput, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        entitlement: MicrotransactionEntitlement;
+        replayed: boolean;
+    }>>;
+    /** Owning user asks support to review a refund. This does not execute payment reversal. */
+    static requestRefund(title_id: string, data: {
+        order_id: string;
+        reason: string;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionRefundRequest>>;
+    /** Trusted title server with commerce:fulfill or admin JWT acknowledges the immutable event. */
+    static acknowledgeDelivery(title_id: string, delivery_id: string, data: {
+        event_id: string;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionDeliveryResult>>;
+    /** Title MCP token, never a runtime install token. Describes arguments, abilities, mutation semantics and provider facts. */
+    static mcpCapabilities(title_id: string, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<MicrotransactionCapabilities>>;
+    /** Execute a discovered authorized operation directly. Legacy confirm is ignored and not forwarded. */
+    static mcpOperation<T = Record<string, unknown>>(title_id: string, operation: MicrotransactionOperation, data: {
+        arguments: Record<string, unknown>;
+        confirm?: boolean;
+    }, options?: MicrotransactionRequestOptions): AxiosPromise<MicrotransactionResponse<{
+        operation: MicrotransactionOperation;
+        result: T;
+    }>>;
+    private static call;
+}
+
+/** A one-time notification, never a receipt or authorization to grant goods. */
+interface MicrotransactionPurchaseMessage {
+    type: 'glitch.microtransaction.updated';
+    version: 1;
+    title_id: string;
+    checkout_session_id: string;
+    order_id: string;
+    /** Cryptographically random value bound to the checkout session at creation. */
+    nonce: string;
+    /** Server-issued one-time code; not an account or player bearer token. */
+    claim_code: string;
+}
+/** Exact authoritative /handoffs/claim response, not the hosted session DTO. */
+type MicrotransactionVerifiedSession = MicrotransactionHandoffClaim;
+interface MicrotransactionBridgeOptions<T extends MicrotransactionVerifiedSession> {
+    titleId: string;
+    checkoutSessionId: string;
+    /** Exact trusted Glitch checkout origin, with no path, wildcard, or credentials. */
+    checkoutOrigin: string;
+    /** The actual Window returned by window.open or the checkout iframe.contentWindow. */
+    checkoutWindow: Window;
+    /** At least 128 bits of randomness; use createMicrotransactionNonce(). */
+    nonce: string;
+    /**
+     * Exchange message.claim_code at Glitch using claimHandoff(titleId,
+     * {claim_code, nonce, return_origin: window.location.origin,
+     * checkout_session_id}). Return response.data.data, the actual claim DTO.
+     * The message has already passed source/origin/nonce checks but is still NOT
+     * proof of payment. The server validates and consumes the one-time code.
+     * Never exchange a site-wide login token with the game or put credentials in
+     * postMessage, analytics, logs, or query strings.
+     */
+    verify: (message: MicrotransactionPurchaseMessage) => Promise<T>;
+    /**
+     * Restore using the previously verified scoped token plus getOrder and
+     * listEntitlements. Return the claim identity/token with current inventory.
+     * Never redeem the code again. When its token expires, return the player to
+     * the authenticated hosted flow to obtain a fresh scoped handoff.
+     */
+    refresh?: (previous: T) => Promise<T>;
+    /** Refresh display/inventory from the verified result. Make local effects idempotent. */
+    onVerified: (result: T) => void | Promise<void>;
+    /** A failed refresh is not a failed payment. Keep the same session and retry. */
+    onError?: (error: unknown) => void;
+    /** Explicit local development only; production checkout must use HTTPS. */
+    allowLocalDevelopment?: boolean;
+    /** Defaults to window. Useful for browser integration tests. */
+    eventTarget?: Pick<Window, 'addEventListener' | 'removeEventListener'>;
+}
+/** Restore authenticates an existing receipt in Glitch and creates a new session. */
+interface MicrotransactionRestoreBridgeOptions<T extends MicrotransactionVerifiedSession> extends Omit<MicrotransactionBridgeOptions<T>, 'checkoutSessionId'> {
+    /** Previously verified receipt/order ID. This, not the old expired session ID, is pinned. */
+    orderId: string;
+}
+interface MicrotransactionBridge {
+    /**
+     * Refresh only after a successful claim, using options.refresh and its scoped
+     * token. Concurrent refreshes share one request. A lost first-claim response
+     * requires a fresh handoff from the authenticated hosted page, not code replay
+     * or a new payment. No automatic polling or token refresh is performed.
+     */
+    refresh(): Promise<void>;
+    /** Remove the listener. In-flight results cannot call onVerified after disposal. */
+    dispose(): void;
+}
+/** Generate a 256-bit browser nonce. Fails closed without secure Web Crypto. */
+declare function createMicrotransactionNonce(): string;
+/**
+ * Listen for Glitch-hosted, game-branded checkout changes with strict origin,
+ * source, title, session, and nonce binding. Message data cannot grant an item.
+ * The caller always verifies the session at Glitch before updating inventory.
+ *
+ * Prefer openMicrotransactionOverlay with the exact server-returned URL. The
+ * game stays mounted; no top-level navigation fallback is permitted. If an
+ * embedded flow is unavailable, show retry/close and preserve the game state.
+ * refresh() requires an already verified claim. Keep
+ * secrets in memory/session storage or a URL fragment, never query parameters.
+ * Dispose on game unmount/account change. Reconnect restores ownership through
+ * the authenticated entitlement API, not a saved "purchase successful" flag.
+ */
+declare function createMicrotransactionBridge<T extends MicrotransactionVerifiedSession>(options: MicrotransactionBridgeOptions<T>): MicrotransactionBridge;
+/**
+ * Restore-only bridge for /games/:titleId/purchases/restore. Pin the prior order,
+ * fresh nonce, exact Glitch origin and opened window. The hosted signed-in page
+ * creates a NEW session; the server-verified claim must match that new session
+ * and the pinned order. This does not relax purchase-session binding.
+ *
+ * Open the hosted restore page, never request the account JWT in the game.
+ * verify(message) exchanges the code using message.checkout_session_id. All
+ * duplicate-code, expiry and same-player refresh safeguards still apply.
+ */
+declare function createMicrotransactionRestoreBridge<T extends MicrotransactionVerifiedSession>(options: MicrotransactionRestoreBridgeOptions<T>): MicrotransactionBridge;
+
+interface MicrotransactionOverlayOptions {
+    titleId: string;
+    /** Exact configured Glitch HTTPS origin, never taken from postMessage data. */
+    checkoutOrigin: string;
+    /** Result of createCheckoutSession or createRestoreSession; keep its capability private. */
+    session: MicrotransactionCreatedCheckoutSession;
+    /** Replace displayed inventory from verified backend data; never increment blindly. */
+    onVerified: (claim: MicrotransactionHandoffClaim) => void | Promise<void>;
+    /** Pause game input/audio here. The SDK never unmounts or resets the game. */
+    onOpen?: () => void;
+    /** Resume game input/audio here. Called once, even on escape/error cleanup. */
+    onClose?: (reason: 'dismissed' | 'completed' | 'unavailable') => void;
+    /** Receipt/status-only update after close; this callback does not authorize item grants. */
+    onOrderUpdate?: (order: MicrotransactionOrder | null) => void | Promise<void>;
+    onError?: (error: unknown) => void;
+    label?: string;
+    /** Permit HTTP loopback/.test origins only for explicit local development. */
+    allowLocalDevelopment?: boolean;
+    /** Defaults to the caller's document, including when the game itself is embedded. */
+    document?: Document;
+    /** Bounded network timeout; defaults to 15 seconds. */
+    timeoutMs?: number;
+    /** Per-phase iframe load/application-ready timeout; 1–60 seconds, defaults to 20 seconds. */
+    frameLoadTimeoutMs?: number;
+}
+/** Hosted page signals usable checkout/account UI, never payment or inventory authority. */
+interface MicrotransactionReadyMessage {
+    type: 'glitch.microtransaction.ready';
+    version: 1;
+    title_id: string;
+    checkout_session_id: string;
+    nonce: string;
+}
+interface MicrotransactionOverlay {
+    readonly element: HTMLDialogElement;
+    readonly iframe: HTMLIFrameElement;
+    /** Refresh verified inventory, or limited receipt status before the first claim. */
+    refresh(): Promise<void>;
+    /** Removes only this modal, restores focus/input, and refreshes authoritative state. */
+    close(reason?: 'dismissed' | 'completed' | 'unavailable'): Promise<void>;
+    /** Reload only the same checkout iframe/session. Never starts another payment. */
+    retry(): void;
+}
+/**
+ * Mount Glitch checkout IN the running game. The game document, URL and session
+ * stay intact. Uses a modal dialog with focus restore and a sandboxed payment
+ * iframe. No top-navigation permission or top-level/popup-blocked fallback exists.
+ * Only bank/OAuth verification may open a controlled provider window from inside
+ * the frame. If embedding is unavailable, show retry/close instead of navigating.
+ *
+ * Receipt messages must originate from this exact iframe.contentWindow and pass
+ * origin/title/session/nonce checks. The SDK redeems the one-time claim at Glitch
+ * and uses the returned scoped player token only on commerce requests. Closing
+ * does not cancel an uncertain payment, grant goods, or discard the game state.
+ */
+declare function openMicrotransactionOverlay(options: MicrotransactionOverlayOptions): MicrotransactionOverlay;
+/** Same in-game modal for anonymous-safe restore sessions; never opens a new payment. */
+declare function openMicrotransactionRestoreOverlay(options: MicrotransactionOverlayOptions): MicrotransactionOverlay;
+
 interface Route {
     url: string;
     method: string;
@@ -11918,13 +13134,17 @@ declare class Requests {
     static put<T>(url: string, data: any, params?: Record<string, any>): AxiosPromise<Response<T>>;
     static patch<T>(url: string, data: any, params?: Record<string, any>): AxiosPromise<Response<T>>;
     static delete<T>(url: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
-    static uploadFile<T>(url: string, filename: string, file: File | Blob, data?: any, params?: Record<string, any>, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void): AxiosPromise<Response<T>>;
+    static uploadFile<T>(url: string, filename: string, file: File | Blob, data?: any, params?: Record<string, any>, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void, options?: Pick<AxiosRequestConfig, 'signal' | 'timeout'> & {
+        excludeCommunityContext?: boolean;
+    }): AxiosPromise<Response<T>>;
     static postFormData<T>(url: string, formData: FormData, params?: Record<string, any>, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void): AxiosPromise<Response<T>>;
     static uploadBlob<T>(url: string, filename: string, blob: Blob, data?: any, params?: Record<string, any>, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void): AxiosPromise<Response<T>>;
     static uploadFileInChunks<T>(file: File, uploadUrl: string, onProgress?: (totalSize: number, amountUploaded: number) => void, data?: any, chunkSize?: number): Promise<void>;
     static processRoute<T>(route: Route, data?: object, routeReplace?: {
         [key: string]: any;
-    }, params?: Record<string, any>): AxiosPromise<Response<T>>;
+    }, params?: Record<string, any>, options?: Pick<AxiosRequestConfig, 'signal' | 'timeout' | 'headers'> & {
+        excludeCommunityContext?: boolean;
+    }): AxiosPromise<Response<T>>;
 }
 
 declare class Parser {
@@ -12238,6 +13458,7 @@ declare class Glitch {
         Newsletters: typeof Newsletters;
         PlayTests: typeof PlayTests;
         Media: typeof Media;
+        FestivalNetworking: typeof FestivalNetworking;
         Scheduler: typeof Scheduler;
         RedditSubreddits: typeof RedditSubreddits;
         Funnel: typeof Funnel;
@@ -12263,6 +13484,7 @@ declare class Glitch {
         GameAdvertising: typeof GameAdvertising;
         Hosting: typeof Hosting;
         GameDesign: typeof GameDesign;
+        Microtransactions: typeof Microtransactions;
     };
     static util: {
         Requests: typeof Requests;
@@ -12352,4 +13574,4 @@ declare class Glitch {
     };
 }
 
-export { Glitch as default };
+export { type FestivalApplicationInput, type FestivalApplicationState, type FestivalConversation, type FestivalMediaUpload, type FestivalNetworkingFilters, type FestivalNetworkingProfile, type FestivalNetworkingResponse, type FestivalNetworkingSettings, type FestivalPost, type FestivalPostInput, type FestivalPostKind, type FestivalPostState, type FestivalPreferences, type FestivalReportInput, type FestivalRequestOptions, type FestivalWorkType, type MicrotransactionAbility, type MicrotransactionBranding, type MicrotransactionBridge, type MicrotransactionBridgeOptions, type MicrotransactionCapabilities, type MicrotransactionCatalog, type MicrotransactionCatalogFilter, type MicrotransactionCheckoutInput, type MicrotransactionCheckoutResult, type MicrotransactionCheckoutSession, type MicrotransactionCheckoutSessionInput, type MicrotransactionConsumeInput, type MicrotransactionCreatedCheckoutSession, type MicrotransactionCurrency, type MicrotransactionDelivery, type MicrotransactionDeliveryListFilters, type MicrotransactionDeliveryResult, type MicrotransactionDeliverySettings, type MicrotransactionDeliverySettingsInput, type MicrotransactionDeliveryStatus, type MicrotransactionEarnings, type MicrotransactionEntitlement, type MicrotransactionEnvironment, type MicrotransactionEnvironmentFilter, type MicrotransactionError, type MicrotransactionErrorCode, type MicrotransactionFramePolicy, type MicrotransactionFulfillmentStatus, type MicrotransactionGrant, type MicrotransactionGrantUsage, type MicrotransactionGrantUsageStatus, type MicrotransactionHandoff, type MicrotransactionHandoffClaim, type MicrotransactionHandoffClaimInput, type MicrotransactionLegacyConfirmation, type MicrotransactionManagementListFilters, type MicrotransactionMedia, type MicrotransactionMyPurchases, type MicrotransactionMyPurchasesFilters, type MicrotransactionOperation, type MicrotransactionOperationCapability, type MicrotransactionOrder, type MicrotransactionOrderDetail, type MicrotransactionOrderListFilters, type MicrotransactionOverlay, type MicrotransactionOverlayOptions, type MicrotransactionPaymentStatus, type MicrotransactionPayout, type MicrotransactionPayoutListFilters, type MicrotransactionPayoutStatus, type MicrotransactionPlayerPurchase, type MicrotransactionPrice, type MicrotransactionProduct, type MicrotransactionProductInput, type MicrotransactionProductListFilters, type MicrotransactionProductStatus, type MicrotransactionProductType, type MicrotransactionProvider, type MicrotransactionProviderConfiguration, type MicrotransactionProviderInput, type MicrotransactionProviderName, type MicrotransactionProviderOnboarding, type MicrotransactionProviderOnboardingInput, type MicrotransactionProviderSku, type MicrotransactionPurchaseInput, type MicrotransactionPurchaseMessage, type MicrotransactionPurchasePagination, type MicrotransactionQuote, type MicrotransactionReadiness, type MicrotransactionReadyMessage, type MicrotransactionRefund, type MicrotransactionRefundInput, type MicrotransactionRefundListFilters, type MicrotransactionRefundRecord, type MicrotransactionRefundRequest, type MicrotransactionRefundStatus, type MicrotransactionRelatedListFilters, type MicrotransactionRequestOptions, type MicrotransactionResponse, type MicrotransactionRestoreBridgeOptions, type MicrotransactionSessionOptions, type MicrotransactionSettings, type MicrotransactionSettingsInput, type MicrotransactionVerifiedSession, createMicrotransactionBridge, createMicrotransactionNonce, createMicrotransactionRestoreBridge, Glitch as default, openMicrotransactionOverlay, openMicrotransactionRestoreOverlay };