glitch-javascript-sdk 3.1.3 → 3.1.5

package/dist/index.d.ts

@@ -3968,6 +3968,41 @@ declare class SocialPosts {
     }): AxiosPromise<Response<T>>;
 }
 
+type GameReviewRecommendation = 'recommended' | 'not_recommended' | 'neutral';
+type GameReviewSentiment = 'positive' | 'mixed' | 'negative';
+type GameReviewVoteType = 'helpful' | 'funny' | 'detailed' | 'not_helpful';
+type GameReviewReportReason = 'abuse' | 'spam' | 'off_topic' | 'manipulation' | 'hate' | 'personal_info' | 'other';
+interface GameReviewRatings {
+    gameplay?: GameReviewSentiment;
+    performance?: GameReviewSentiment;
+    value?: GameReviewSentiment;
+    content?: GameReviewSentiment;
+    multiplayer?: GameReviewSentiment;
+    monetization?: GameReviewSentiment;
+    stability?: GameReviewSentiment;
+    localization?: GameReviewSentiment;
+    accessibility?: GameReviewSentiment;
+}
+interface CreateGameReviewRequest {
+    recommendation: GameReviewRecommendation;
+    title: string;
+    body: string;
+    review_type?: 'first_impression' | 'full_review' | 'bug_performance_warning' | 'early_access_feedback' | 'multiplayer_community_feedback' | 'monetization_pricing_feedback' | 'changed_opinion_after_update';
+    liked?: string;
+    needs_work?: string;
+    audience?: string;
+    language?: string;
+    game_version?: string;
+    platform?: string;
+    acquisition_type?: 'purchased' | 'free_to_play' | 'free_copy' | 'promotional_key' | 'beta_key' | 'demo' | 'external_verified';
+    received_for_free?: boolean;
+    early_access?: boolean;
+    current_version_review?: boolean;
+    main_negative_reason?: 'bugs_crashes' | 'bad_performance' | 'not_enough_content' | 'misleading_marketing' | 'price_value' | 'monetization' | 'community_toxicity' | 'developer_business_decision' | 'localization' | 'server_network' | 'gameplay_design' | 'not_my_type' | 'other';
+    change_reason?: string;
+    ratings?: GameReviewRatings;
+}
+type UpdateGameReviewRequest = Partial<CreateGameReviewRequest>;
 declare class Titles {
     /**
      * List all the Titles.
@@ -4609,10 +4644,12 @@ declare class Titles {
      * @param params
      *   - window: number (hours, default 24)
      *   - limit: number (default 10)
+     *   - is_nsfw: 1 for adult titles only, 0 for safe titles only
      */
     static getCommunityActivity<T>(params?: {
         window?: number;
         limit?: number;
+        is_nsfw?: number | boolean;
     }): AxiosPromise<Response<T>>;
     /**
      * Get games trending on social media.
@@ -4621,11 +4658,13 @@ declare class Titles {
      *   - type: 'influencer' (campaigns) or 'organic' (non-paid)
      *   - window: number (hours, default 168)
      *   - limit: number (default 10)
+     *   - is_nsfw: 1 for adult titles only, 0 for safe titles only
      */
     static getSocialTrending<T>(params: {
         type: 'influencer' | 'organic';
         window?: number;
         limit?: number;
+        is_nsfw?: number | boolean;
     }): AxiosPromise<Response<T>>;
     /**
      * Get a personalized discovery queue of games.
@@ -4633,10 +4672,12 @@ declare class Titles {
      * @param params
      *   - limit: number (default 12)
      *   - device_id: string (highly recommended for guest tracking)
+     *   - is_nsfw: 1 for adult titles only, 0 for safe titles only
      */
     static getDiscoveryQueue<T>(params?: {
         limit?: number;
         device_id?: string;
+        is_nsfw?: number | boolean;
     }): AxiosPromise<Response<T>>;
     /**
     * Get a curated, playable feed for the Swipe interface.
@@ -4648,6 +4689,7 @@ declare class Titles {
     *   - seed?: number (For consistent randomization)
     *   - genres?: string[] (Filter by genre names)
     *   - models?: string[] (premium, rental, subscription, free)
+    *   - is_nsfw?: 1 | 0 (1 for adult titles only, 0 for safe titles only)
     *   - excluded_ids?: string[] (UUIDs to skip)
     *   - page?: number
     *   - per_page?: number
@@ -4668,6 +4710,55 @@ declare class Titles {
     static wishlistConversions<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
     static wishlistGeo<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
     static wishlistDevices<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
+    /**
+     * List public reviews for a title.
+     *
+     * @param title_id The UUID of the title.
+     * @param params Optional filters: recommendation, language, current_version_only,
+     * verified_only, platform, acquisition_type, complaint, playtime, sort, per_page.
+     */
+    static listReviews<T>(title_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
+    /**
+     * Get aggregate review scores and structured praise/complaint summaries.
+     */
+    static reviewSummary<T>(title_id: string, params?: {
+        language?: string;
+    }): AxiosPromise<Response<T>>;
+    /**
+     * Create the current user's review for a title. The backend verifies play/purchase eligibility.
+     */
+    static createReview<T>(title_id: string, data: CreateGameReviewRequest): AxiosPromise<Response<T>>;
+    /**
+     * View a single review, including revision history when the backend includes it.
+     */
+    static viewReview<T>(review_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
+    /**
+     * Update the current user's review and preserve a backend revision trail.
+     */
+    static updateReview<T>(review_id: string, data: UpdateGameReviewRequest): AxiosPromise<Response<T>>;
+    /**
+     * Delete the current user's review, or a title admin's moderated review.
+     */
+    static deleteReview<T>(review_id: string): AxiosPromise<Response<T>>;
+    /**
+     * Vote on a review as helpful, funny, detailed, or not helpful.
+     */
+    static voteReview<T>(review_id: string, vote_type: GameReviewVoteType): AxiosPromise<Response<T>>;
+    /**
+     * Report a review for moderation.
+     */
+    static reportReview<T>(review_id: string, data: {
+        reason: GameReviewReportReason;
+        notes?: string;
+    }): AxiosPromise<Response<T>>;
+    /**
+     * Create or update the title developer's official response to a review.
+     */
+    static respondToReview<T>(review_id: string, data: {
+        body: string;
+        linked_patch_note_id?: string;
+        issue_marked_fixed?: boolean;
+    }): AxiosPromise<Response<T>>;
 }
 
 declare class Campaigns {
@@ -7074,6 +7165,11 @@ declare class Scheduler {
      * @param params { is_personalized: boolean }
      */
     static getTikTokTrendingKeywords<T>(scheduler_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
+    /**
+     * Get recommended search keywords on TikTok.
+     * @param params { is_personalized: boolean }
+     */
+    static getTikTokRecommendedKeywords<T>(scheduler_id: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
 }
 
 declare class Funnel {
@@ -8079,6 +8175,880 @@ declare class Crm {
     static deleteContact<T>(contact_id: string): AxiosPromise<Response<T>>;
 }
 
+type MultiplayerLobbyType = 'public' | 'invisible' | 'friends_only' | 'private';
+type MultiplayerLobbyState = 'waiting' | 'ready' | 'in_game' | 'closed';
+type MultiplayerLobbyMemberStatus = 'joined' | 'left' | 'disconnected' | 'kicked' | 'banned';
+type MultiplayerLobbyMessageType = 'chat' | 'binary' | 'system' | 'ready' | 'invite' | 'kick' | 'voice';
+type MultiplayerServerType = 'dedicated' | 'listen' | 'relay';
+type MultiplayerServerStatus = 'active' | 'available' | 'draining' | 'offline';
+type MultiplayerTransport = 'udp' | 'tcp' | 'webrtc' | 'relay';
+type MultiplayerSessionState = 'reserved' | 'active' | 'released' | 'expired';
+type MultiplayerAuthTicketStatus = 'active' | 'consumed' | 'revoked' | 'expired';
+type MultiplayerFavoriteKind = 'favorite' | 'history';
+type MultiplayerVoiceProvider = 'glitch_relay' | 'external';
+type MultiplayerVoiceTopology = 'lobby' | 'server' | 'party' | 'proximity';
+type MultiplayerVoiceState = 'active' | 'closed';
+type MultiplayerVoiceCodec = 'opus' | 'pcm16' | 'aac';
+type MultiplayerVoiceParticipantStatus = 'joined' | 'left' | 'muted' | 'kicked';
+type MultiplayerVoicePacketType = 'audio' | 'speaking' | 'mute_state' | 'offer' | 'answer' | 'ice' | 'control';
+type MultiplayerMetadata = Record<string, any>;
+interface MultiplayerLobbyMember {
+    id: string;
+    lobby_id: string;
+    player_id: string;
+    user_id?: string | null;
+    display_name?: string | null;
+    status: MultiplayerLobbyMemberStatus;
+    ready: boolean;
+    member_data: MultiplayerMetadata;
+    joined_at?: string | null;
+    last_seen_at?: string | null;
+    left_at?: string | null;
+}
+interface MultiplayerServer {
+    id: string;
+    title_id: string;
+    name: string;
+    server_type: MultiplayerServerType;
+    status: MultiplayerServerStatus;
+    region?: string | null;
+    build_version?: string | null;
+    host?: string | null;
+    game_port?: number | null;
+    query_port?: number | null;
+    transport: MultiplayerTransport;
+    connection_uri?: string | null;
+    max_players: number;
+    current_players: number;
+    bot_players: number;
+    secure: boolean;
+    password_protected: boolean;
+    private: boolean;
+    tags: string[];
+    rules: MultiplayerMetadata;
+    metadata: MultiplayerMetadata;
+    last_heartbeat_at?: string | null;
+    expires_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerLobby {
+    id: string;
+    title_id: string;
+    server_id?: string | null;
+    owner_player_id: string;
+    owner_user_id?: string | null;
+    lobby_type: MultiplayerLobbyType;
+    state: MultiplayerLobbyState;
+    joinable: boolean;
+    max_members: number;
+    member_count: number;
+    region?: string | null;
+    game_mode?: string | null;
+    map_name?: string | null;
+    skill_band?: number | null;
+    metadata: MultiplayerMetadata;
+    last_activity_at?: string | null;
+    expires_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+    members?: MultiplayerLobbyMember[];
+    server?: MultiplayerServer | null;
+}
+interface MultiplayerLobbyMessage {
+    id: string;
+    lobby_id: string;
+    player_id: string;
+    user_id?: string | null;
+    message_type: MultiplayerLobbyMessageType;
+    payload: MultiplayerMetadata;
+    sequence: number;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerSession {
+    id: string;
+    title_id: string;
+    server_id?: string | null;
+    lobby_id?: string | null;
+    player_id: string;
+    user_id?: string | null;
+    state: MultiplayerSessionState;
+    connection_payload: MultiplayerMetadata;
+    last_heartbeat_at?: string | null;
+    expires_at?: string | null;
+    started_at?: string | null;
+    ended_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerAuthTicket {
+    id: string;
+    title_id: string;
+    player_id: string;
+    user_id?: string | null;
+    remote_identity?: string | null;
+    status: MultiplayerAuthTicketStatus;
+    issued_at?: string | null;
+    expires_at?: string | null;
+    consumed_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerServerFavorite {
+    id: string;
+    title_id: string;
+    server_id?: string | null;
+    user_id?: string | null;
+    player_id: string;
+    kind: MultiplayerFavoriteKind;
+    name?: string | null;
+    host?: string | null;
+    game_port?: number | null;
+    query_port?: number | null;
+    metadata: MultiplayerMetadata;
+    last_played_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerVoiceParticipant {
+    id: string;
+    voice_room_id: string;
+    player_id: string;
+    user_id?: string | null;
+    display_name?: string | null;
+    status: MultiplayerVoiceParticipantStatus;
+    muted: boolean;
+    deafened: boolean;
+    speaking: boolean;
+    last_sequence: number;
+    metadata: MultiplayerMetadata;
+    joined_at?: string | null;
+    last_heartbeat_at?: string | null;
+    left_at?: string | null;
+    expires_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerVoiceRoom {
+    id: string;
+    title_id: string;
+    lobby_id?: string | null;
+    server_id?: string | null;
+    owner_player_id: string;
+    owner_user_id?: string | null;
+    provider: MultiplayerVoiceProvider;
+    topology: MultiplayerVoiceTopology;
+    state: MultiplayerVoiceState;
+    region?: string | null;
+    codec: MultiplayerVoiceCodec;
+    sample_rate: number;
+    bitrate: number;
+    frame_duration_ms: 10 | 20 | 40 | 60;
+    channels: 1 | 2;
+    max_participants: number;
+    participant_count: number;
+    recording_allowed: boolean;
+    moderation_enabled: boolean;
+    connection_config: MultiplayerMetadata;
+    metadata: MultiplayerMetadata;
+    last_activity_at?: string | null;
+    expires_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+    participants?: MultiplayerVoiceParticipant[];
+}
+interface MultiplayerVoicePacket {
+    id: string;
+    voice_room_id: string;
+    participant_id?: string | null;
+    player_id: string;
+    packet_type: MultiplayerVoicePacketType;
+    payload: string;
+    sequence: number;
+    duration_ms?: number | null;
+    sent_at?: string | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+interface MultiplayerLobbySearchParams {
+    region?: string;
+    game_mode?: string;
+    map_name?: string;
+    lobby_type?: MultiplayerLobbyType;
+    skill_band?: number;
+    limit?: number;
+}
+interface MultiplayerCreateLobbyRequest {
+    player_id?: string;
+    display_name?: string;
+    member_data?: MultiplayerMetadata;
+    lobby_type?: MultiplayerLobbyType;
+    state?: MultiplayerLobbyState;
+    joinable?: boolean;
+    max_members?: number;
+    region?: string;
+    game_mode?: string;
+    map_name?: string;
+    skill_band?: number;
+    metadata?: MultiplayerMetadata;
+    expires_at?: string;
+}
+interface MultiplayerJoinLobbyRequest {
+    player_id?: string;
+    display_name?: string;
+    ready?: boolean;
+    member_data?: MultiplayerMetadata;
+}
+interface MultiplayerLeaveLobbyRequest {
+    player_id?: string;
+}
+interface MultiplayerUpdateLobbyRequest {
+    player_id?: string;
+    lobby_type?: MultiplayerLobbyType;
+    state?: MultiplayerLobbyState;
+    joinable?: boolean;
+    max_members?: number;
+    region?: string;
+    game_mode?: string;
+    map_name?: string;
+    skill_band?: number;
+    metadata?: MultiplayerMetadata;
+    expires_at?: string;
+}
+interface MultiplayerSetLobbyServerRequest {
+    player_id?: string;
+    server_id: string;
+    state?: MultiplayerLobbyState;
+    joinable?: boolean;
+}
+interface MultiplayerLobbyMessagesParams {
+    after_sequence?: number;
+    limit?: number;
+}
+interface MultiplayerSendLobbyMessageRequest {
+    player_id?: string;
+    message_type?: MultiplayerLobbyMessageType;
+    payload: MultiplayerMetadata;
+}
+interface MultiplayerServerBrowserParams {
+    region?: string;
+    build_version?: string;
+    transport?: MultiplayerTransport;
+    status?: MultiplayerServerStatus;
+    secure?: boolean;
+    include_private?: boolean;
+    limit?: number;
+}
+interface MultiplayerRegisterServerRequest {
+    name: string;
+    server_type?: MultiplayerServerType;
+    status?: MultiplayerServerStatus;
+    region?: string;
+    build_version?: string;
+    host?: string;
+    game_port?: number;
+    query_port?: number;
+    transport?: MultiplayerTransport;
+    connection_uri?: string;
+    max_players?: number;
+    current_players?: number;
+    bot_players?: number;
+    secure?: boolean;
+    password_protected?: boolean;
+    private?: boolean;
+    tags?: string[];
+    rules?: MultiplayerMetadata;
+    metadata?: MultiplayerMetadata;
+    expires_at?: string;
+}
+interface MultiplayerRegisterServerResponse {
+    server: MultiplayerServer;
+    server_token: string;
+}
+interface MultiplayerServerHeartbeatRequest {
+    server_token: string;
+    status?: MultiplayerServerStatus;
+    current_players?: number;
+    bot_players?: number;
+    rules?: MultiplayerMetadata;
+    metadata?: MultiplayerMetadata;
+}
+interface MultiplayerReserveServerRequest {
+    player_id?: string;
+    lobby_id?: string;
+    ttl_minutes?: number;
+}
+interface MultiplayerReserveServerResponse {
+    session: MultiplayerSession;
+    reservation_token: string;
+}
+interface MultiplayerSessionHeartbeatRequest {
+    reservation_token: string;
+    state?: Extract<MultiplayerSessionState, 'reserved' | 'active'>;
+    ttl_minutes?: number;
+}
+interface MultiplayerSessionReleaseRequest {
+    reservation_token: string;
+}
+interface MultiplayerIssueAuthTicketRequest {
+    player_id?: string;
+    remote_identity?: string;
+    ttl_minutes?: number;
+}
+interface MultiplayerIssueAuthTicketResponse {
+    ticket: MultiplayerAuthTicket;
+    auth_ticket: string;
+}
+interface MultiplayerValidateAuthTicketRequest {
+    auth_ticket: string;
+    remote_identity?: string;
+    consume?: boolean;
+}
+interface MultiplayerValidateAuthTicketForServerRequest extends MultiplayerValidateAuthTicketRequest {
+    server_token: string;
+}
+interface MultiplayerValidateAuthTicketResponse {
+    valid: boolean;
+    ticket: MultiplayerAuthTicket;
+}
+interface MultiplayerFavoritesParams {
+    player_id?: string;
+    kind?: MultiplayerFavoriteKind;
+}
+interface MultiplayerFavoriteRequest {
+    player_id?: string;
+    server_id?: string;
+    kind?: MultiplayerFavoriteKind;
+    name?: string;
+    host?: string;
+    game_port?: number;
+    query_port?: number;
+    metadata?: MultiplayerMetadata;
+    last_played_at?: string;
+}
+interface MultiplayerDeleteFavoriteParams {
+    player_id?: string;
+}
+interface MultiplayerDeleteFavoriteResponse {
+    deleted: boolean;
+}
+interface MultiplayerVoiceRoomListParams {
+    lobby_id?: string;
+    server_id?: string;
+    provider?: MultiplayerVoiceProvider;
+    topology?: MultiplayerVoiceTopology;
+    state?: MultiplayerVoiceState;
+    region?: string;
+    limit?: number;
+}
+interface MultiplayerCreateVoiceRoomRequest {
+    player_id?: string;
+    display_name?: string;
+    lobby_id?: string;
+    server_id?: string;
+    provider?: MultiplayerVoiceProvider;
+    topology?: MultiplayerVoiceTopology;
+    state?: MultiplayerVoiceState;
+    region?: string;
+    codec?: MultiplayerVoiceCodec;
+    sample_rate?: number;
+    bitrate?: number;
+    frame_duration_ms?: 10 | 20 | 40 | 60;
+    channels?: 1 | 2;
+    max_participants?: number;
+    recording_allowed?: boolean;
+    moderation_enabled?: boolean;
+    connection_config?: MultiplayerMetadata;
+    metadata?: MultiplayerMetadata;
+    ttl_minutes?: number;
+    expires_at?: string;
+}
+interface MultiplayerUpdateVoiceRoomRequest {
+    player_id?: string;
+    state?: MultiplayerVoiceState;
+    max_participants?: number;
+    recording_allowed?: boolean;
+    moderation_enabled?: boolean;
+    connection_config?: MultiplayerMetadata;
+    metadata?: MultiplayerMetadata;
+    expires_at?: string;
+}
+interface MultiplayerJoinVoiceRoomRequest {
+    player_id?: string;
+    display_name?: string;
+    metadata?: MultiplayerMetadata;
+    ttl_minutes?: number;
+}
+interface MultiplayerVoiceRoomTokenResponse {
+    voice_room: MultiplayerVoiceRoom;
+    participant: MultiplayerVoiceParticipant;
+    voice_token: string;
+}
+interface MultiplayerVoiceHeartbeatRequest {
+    voice_token: string;
+    muted?: boolean;
+    deafened?: boolean;
+    speaking?: boolean;
+    last_sequence?: number;
+    ttl_minutes?: number;
+}
+interface MultiplayerVoiceLeaveRequest {
+    voice_token: string;
+}
+interface MultiplayerVoicePacketRequest {
+    voice_token: string;
+    packet_type?: MultiplayerVoicePacketType;
+    payload: string;
+    duration_ms?: number;
+}
+interface MultiplayerVoicePollRequest {
+    voice_token: string;
+    after_sequence?: number;
+    limit?: number;
+    exclude_self?: boolean;
+}
+/**
+ * Steam-style multiplayer APIs for Glitch titles.
+ *
+ * The multiplayer surface is split into three groups:
+ * lobby coordination, voice coordination, server browser/reservations, and short-lived auth tickets.
+ * User JWTs can infer the player from the authenticated user. Title-token clients
+ * and game clients without a Glitch user session should pass a stable `player_id`.
+ * Dedicated servers use `server_token` on heartbeat and server-side ticket validation
+ * so they do not need to hold a user JWT or title token.
+ *
+ * These endpoints are intentionally database-agnostic from the SDK's point of view:
+ * callers work with public identifiers, metadata objects, and lifecycle events,
+ * while the backend owns how those records are stored.
+ */
+declare class Multiplayer {
+    /**
+     * Search joinable, non-expired lobbies for a title.
+     *
+     * Filters are exact-match except `skill_band`, which the backend can use for
+     * near sorting. Default results exclude full, closed, unjoinable, and expired
+     * lobbies. Lifecycle context: clients usually call this before `joinLobby`;
+     * joins create a `lobby.joined` event on the backend.
+     *
+     * @param title_id Title UUID.
+     * @param params Optional filters such as region, game mode, map, lobby type, skill band, and limit.
+     * @example
+     * Multiplayer.searchLobbies('title-uuid', {
+     *   region: 'us-central',
+     *   game_mode: 'ranked_duos',
+     *   skill_band: 1840,
+     *   limit: 25
+     * });
+     */
+    static searchLobbies<T = MultiplayerLobby[]>(title_id: string, params?: MultiplayerLobbySearchParams): AxiosPromise<Response<T>>;
+    /**
+     * Create a lobby and insert the owner as the first joined member.
+     *
+     * Use this when matchmaking has no suitable lobby, when a player invites
+     * friends, or when a party needs pre-game setup before server assignment.
+     * Lifecycle events: `lobby.created`, then `lobby.joined` for the owner.
+     *
+     * @param title_id Title UUID.
+     * @param data Lobby configuration and optional owner/member metadata.
+     * @example
+     * Multiplayer.createLobby('title-uuid', {
+     *   player_id: 'steam:76561198000000000',
+     *   display_name: 'CinderAce',
+     *   lobby_type: 'public',
+     *   max_members: 4,
+     *   region: 'us-central',
+     *   game_mode: 'ranked_duos',
+     *   metadata: { playlist: 'ranked', allow_voice: true }
+     * });
+     */
+    static createLobby<T = MultiplayerLobby>(title_id: string, data: MultiplayerCreateLobbyRequest): AxiosPromise<Response<T>>;
+    /**
+     * Retrieve a lobby with members and assigned server information when present.
+     *
+     * Call this after lobby lifecycle notifications such as `lobby.joined`,
+     * `lobby.updated`, `lobby.owner_transferred`, or `lobby.server_assigned`.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     */
+    static showLobby<T = MultiplayerLobby>(title_id: string, lobby_id: string): AxiosPromise<Response<T>>;
+    /**
+     * Join a lobby or refresh an existing membership.
+     *
+     * This call is idempotent for a player already in the lobby and can update
+     * display name, ready state, or member metadata. It returns 409 when the lobby
+     * is full, closed, expired, or not joinable. Lifecycle event: `lobby.joined`.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     * @param data Player identity and optional member metadata.
+     * @example
+     * Multiplayer.joinLobby('title-uuid', 'lobby-uuid', {
+     *   player_id: 'steam:76561198000000001',
+     *   display_name: 'Nova',
+     *   ready: false,
+     *   member_data: { character: 'Ash', rank: 1799 }
+     * });
+     */
+    static joinLobby<T = MultiplayerLobbyMember>(title_id: string, lobby_id: string, data: MultiplayerJoinLobbyRequest): AxiosPromise<Response<T>>;
+    /**
+     * Leave a lobby.
+     *
+     * If the owner leaves, ownership transfers to the oldest remaining joined
+     * member. If no members remain, the lobby closes. Lifecycle events:
+     * `lobby.left`, optionally `lobby.owner_transferred` or `lobby.updated`.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     * @param data Optional player_id for title-token clients.
+     */
+    static leaveLobby<T = MultiplayerLobbyMember | null>(title_id: string, lobby_id: string, data?: MultiplayerLeaveLobbyRequest): AxiosPromise<Response<T>>;
+    /**
+     * Update lobby metadata, visibility, joinability, limits, or state.
+     *
+     * This is owner-only. `max_members` cannot be lower than the current member
+     * count. Keep metadata low-frequency and mostly search/display oriented.
+     * Lifecycle event: `lobby.updated`.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     * @param data Owner identity plus fields to update.
+     */
+    static updateLobby<T = MultiplayerLobby>(title_id: string, lobby_id: string, data: MultiplayerUpdateLobbyRequest): AxiosPromise<Response<T>>;
+    /**
+     * Assign a registered game server to a lobby.
+     *
+     * This owner-only handoff mirrors Steam's SetLobbyGameServer flow. Clients
+     * should react by reserving or connecting to the assigned server, then
+     * optionally leaving the lobby. Lifecycle event: `lobby.server_assigned`.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     * @param data Server UUID and optional lobby state/joinability updates.
+     */
+    static setLobbyServer<T = MultiplayerLobby>(title_id: string, lobby_id: string, data: MultiplayerSetLobbyServerRequest): AxiosPromise<Response<T>>;
+    /**
+     * List ordered low-bandwidth lobby messages.
+     *
+     * Use `after_sequence` to poll for messages missed during reconnects or after
+     * a realtime `lobby.message_sent` event. This channel is for chat and control
+     * messages, not gameplay, positional data, or voice streaming.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     * @param params Optional sequence cursor and limit.
+     */
+    static listLobbyMessages<T = MultiplayerLobbyMessage[]>(title_id: string, lobby_id: string, params?: MultiplayerLobbyMessagesParams): AxiosPromise<Response<T>>;
+    /**
+     * Send a low-bandwidth message to all lobby members.
+     *
+     * Payloads are capped at 4KB by the backend. Use this for chat, ready signals,
+     * invite/kick control messages, and owner-arbitrated choices. Lifecycle event:
+     * `lobby.message_sent`.
+     *
+     * @param title_id Title UUID.
+     * @param lobby_id Lobby UUID.
+     * @param data Message type, sender identity, and JSON payload.
+     * @example
+     * Multiplayer.sendLobbyMessage('title-uuid', 'lobby-uuid', {
+     *   player_id: 'steam:76561198000000000',
+     *   message_type: 'ready',
+     *   payload: { ready: true }
+     * });
+     */
+    static sendLobbyMessage<T = MultiplayerLobbyMessage>(title_id: string, lobby_id: string, data: MultiplayerSendLobbyMessageRequest): AxiosPromise<Response<T>>;
+    /**
+     * List active/non-expired voice rooms for a title.
+     *
+     * Rooms can be attached to a lobby, a server, a party, or a proximity group.
+     * Use this to discover existing voice state before joining. Lifecycle context:
+     * realtime transports should mirror `voice.room_created`, `voice.room_updated`,
+     * `voice.joined`, and `voice.left`.
+     *
+     * @param title_id Title UUID.
+     * @param params Optional room filters such as lobby_id, server_id, provider, topology, state, region, and limit.
+     */
+    static listVoiceRooms<T = MultiplayerVoiceRoom[]>(title_id: string, params?: MultiplayerVoiceRoomListParams): AxiosPromise<Response<T>>;
+    /**
+     * Create a voice room and join the creator as the first participant.
+     *
+     * The backend returns `voice_token` once. Keep it client-side and use it for
+     * voice heartbeat, packet send, packet polling, and leave calls. `glitch_relay`
+     * can carry base64 Opus frames for prototypes, small-party fallback, or
+     * signaling. For production-scale audio, set `provider: 'external'` and reuse
+     * the room/token contract with WebRTC, an SFU, Vivox, Steam Networking, or an
+     * engine-native transport. Lifecycle events: `voice.room_created`,
+     * `voice.joined`.
+     *
+     * @param title_id Title UUID.
+     * @param data Voice codec, topology, linked lobby/server, and owner metadata.
+     * @example
+     * const { data } = await Multiplayer.createVoiceRoom('title-uuid', {
+     *   player_id: 'steam:76561198000000000',
+     *   display_name: 'CinderAce',
+     *   lobby_id: 'lobby-uuid',
+     *   provider: 'glitch_relay',
+     *   topology: 'lobby',
+     *   codec: 'opus',
+     *   sample_rate: 48000,
+     *   frame_duration_ms: 20,
+     *   channels: 1,
+     *   metadata: { push_to_talk: true }
+     * });
+     */
+    static createVoiceRoom<T = MultiplayerVoiceRoomTokenResponse>(title_id: string, data: MultiplayerCreateVoiceRoomRequest): AxiosPromise<Response<T>>;
+    /**
+     * Retrieve a voice room with participant media states.
+     *
+     * Use this after `voice.joined`, `voice.heartbeat`, `voice.left`, or
+     * `voice.room_updated` to refresh in-game UI such as speaker lists, mute
+     * icons, or team voice controls.
+     *
+     * @param title_id Title UUID.
+     * @param voice_room_id Voice room UUID.
+     */
+    static showVoiceRoom<T = MultiplayerVoiceRoom>(title_id: string, voice_room_id: string): AxiosPromise<Response<T>>;
+    /**
+     * Update owner-controlled voice room state.
+     *
+     * Owner-only. Use this to close a room, adjust capacity, update moderation
+     * flags, or provide external provider connection details. The backend rejects
+     * lowering `max_participants` below the current participant count. Lifecycle
+     * event: `voice.room_updated`.
+     *
+     * @param title_id Title UUID.
+     * @param voice_room_id Voice room UUID.
+     * @param data Owner player identity and room fields to update.
+     */
+    static updateVoiceRoom<T = MultiplayerVoiceRoom>(title_id: string, voice_room_id: string, data: MultiplayerUpdateVoiceRoomRequest): AxiosPromise<Response<T>>;
+    /**
+     * Join a voice room and receive a participant-scoped token.
+     *
+     * Rejoining with the same player is idempotent and rotates the token. The
+     * token is used by participant endpoints instead of requiring a user JWT or
+     * title token on every media request. Returns 409 when the room is closed,
+     * expired, or full. Lifecycle event: `voice.joined`.
+     *
+     * @param title_id Title UUID.
+     * @param voice_room_id Voice room UUID.
+     * @param data Player identity, display name, metadata, and token TTL.
+     */
+    static joinVoiceRoom<T = MultiplayerVoiceRoomTokenResponse>(title_id: string, voice_room_id: string, data: MultiplayerJoinVoiceRoomRequest): AxiosPromise<Response<T>>;
+    /**
+     * Heartbeat voice participant state.
+     *
+     * Call every 10-30 seconds and whenever mute/deafen/speaking state changes.
+     * `last_sequence` tells the backend how far this participant has processed
+     * ordered packets. Expired participants are rejected with 409. Lifecycle event:
+     * `voice.heartbeat`.
+     *
+     * @param data Participant voice token and mutable media state.
+     */
+    static heartbeatVoice<T = MultiplayerVoiceParticipant>(data: MultiplayerVoiceHeartbeatRequest): AxiosPromise<Response<T>>;
+    /**
+     * Leave the current voice room for a participant token.
+     *
+     * This is idempotent for disconnect cleanup: room participant count is
+     * decremented once, room ownership is transferred when possible, and an
+     * empty room closes. The token remains valid only for retrying this leave
+     * call; heartbeat, send, and poll calls reject left participants. Lifecycle
+     * event: `voice.left`.
+     *
+     * @param data Participant voice token.
+     */
+    static leaveVoice<T = MultiplayerVoiceParticipant>(data: MultiplayerVoiceLeaveRequest): AxiosPromise<Response<T>>;
+    /**
+     * Send one ordered voice-room packet.
+     *
+     * `audio` packets should contain compact compressed frames such as base64 Opus
+     * at 48kHz mono/20ms. `offer`, `answer`, and `ice` packets support WebRTC
+     * signaling. `control`, `speaking`, and `mute_state` packets are for custom
+     * engine state. Audio payloads are capped at 16KB; non-audio packets at 4KB.
+     * Muted participants cannot send audio. Lifecycle event: `voice.packet_sent`.
+     *
+     * @param data Participant token, packet type, payload, and optional duration.
+     * @example
+     * await Multiplayer.sendVoicePacket({
+     *   voice_token: voiceToken,
+     *   packet_type: 'audio',
+     *   payload: base64OpusFrame,
+     *   duration_ms: 20
+     * });
+     */
+    static sendVoicePacket<T = MultiplayerVoicePacket>(data: MultiplayerVoicePacketRequest): AxiosPromise<Response<T>>;
+    /**
+     * Poll ordered voice-room packets after a known sequence.
+     *
+     * Defaults to excluding packets sent by the caller. Use the highest returned
+     * sequence as the next `after_sequence` cursor. This is useful for fallback
+     * relay, WebRTC signaling, reconnect recovery, and small-party prototypes.
+     * Lifecycle event: `voice.packet_polled`.
+     *
+     * @param data Participant token, optional sequence cursor, limit, and self-exclusion flag.
+     */
+    static pollVoicePackets<T = MultiplayerVoicePacket[]>(data: MultiplayerVoicePollRequest): AxiosPromise<Response<T>>;
+    /**
+     * Browse public, joinable multiplayer servers for a title.
+     *
+     * Default results exclude private, draining, offline, stale, expired, and full
+     * servers. Title administrators can pass `include_private` to inspect servers
+     * that normal clients cannot join.
+     *
+     * @param title_id Title UUID.
+     * @param params Optional server browser filters.
+     */
+    static browseServers<T = MultiplayerServer[]>(title_id: string, params?: MultiplayerServerBrowserParams): AxiosPromise<Response<T>>;
+    /**
+     * Register or refresh a multiplayer server and receive a one-time server token.
+     *
+     * Store `server_token` only on the server process. The backend stores only a
+     * hash and will not return the plain token again. Counts are validated so
+     * `current_players + bot_players` cannot exceed `max_players`. Lifecycle event:
+     * `server.registered`.
+     *
+     * @param title_id Title UUID.
+     * @param data Server browser, connection, rule, and capacity metadata.
+     * @example
+     * Multiplayer.registerServer('title-uuid', {
+     *   name: 'Ranked US Central 01',
+     *   server_type: 'dedicated',
+     *   status: 'active',
+     *   host: '203.0.113.42',
+     *   game_port: 7777,
+     *   query_port: 27015,
+     *   transport: 'udp',
+     *   max_players: 16,
+     *   secure: true,
+     *   tags: ['ranked', 'duos']
+     * });
+     */
+    static registerServer<T = MultiplayerRegisterServerResponse>(title_id: string, data: MultiplayerRegisterServerRequest): AxiosPromise<Response<T>>;
+    /**
+     * Heartbeat a multiplayer server with its dedicated `server_token`.
+     *
+     * Call every 30-60 seconds and whenever player counts, rules, or metadata
+     * change. Stale servers are hidden from default browsing and reservation.
+     * This endpoint is for dedicated/listen server processes and does not require
+     * a user JWT. Lifecycle event: `server.heartbeat`.
+     *
+     * @param title_id Title UUID.
+     * @param server_id Server UUID.
+     * @param data Server token and optional mutable server state.
+     */
+    static heartbeatServer<T = MultiplayerServer>(title_id: string, server_id: string, data: MultiplayerServerHeartbeatRequest): AxiosPromise<Response<T>>;
+    /**
+     * Reserve a short-lived slot on a multiplayer server before connecting.
+     *
+     * Reservations protect capacity during game handoff. The backend rejects stale,
+     * private, full, draining, offline, expired, or duplicate open reservations.
+     * The plain `reservation_token` is returned once and is used for session
+     * heartbeat/release calls. Lifecycle event: `server.reserved`.
+     *
+     * @param title_id Title UUID.
+     * @param server_id Server UUID.
+     * @param data Optional player/lobby identity and reservation TTL.
+     */
+    static reserveServer<T = MultiplayerReserveServerResponse>(title_id: string, server_id: string, data?: MultiplayerReserveServerRequest): AxiosPromise<Response<T>>;
+    /**
+     * Heartbeat an open multiplayer session reservation.
+     *
+     * Use this after a successful reservation while the client is connecting or
+     * playing. Expired sessions are marked expired and capacity is recovered before
+     * the backend returns 409. Lifecycle events: `session.heartbeat` or
+     * `session.expired`.
+     *
+     * @param data Reservation token and optional state/TTL.
+     */
+    static heartbeatSession<T = MultiplayerSession>(data: MultiplayerSessionHeartbeatRequest): AxiosPromise<Response<T>>;
+    /**
+     * Release an open multiplayer session reservation.
+     *
+     * Call this on normal disconnect, failed connection attempts, or shutdown so
+     * server capacity is decremented promptly. The backend makes release safe to
+     * call more than once for an already closed reservation. Lifecycle event:
+     * `session.released`.
+     *
+     * @param data Reservation token returned by `reserveServer`.
+     */
+    static releaseSession<T = MultiplayerSession>(data: MultiplayerSessionReleaseRequest): AxiosPromise<Response<T>>;
+    /**
+     * Issue a short-lived multiplayer auth ticket for a player.
+     *
+     * The plain `auth_ticket` is returned once and only a hash is stored by the
+     * backend. Use this for P2P or dedicated-server admission before game traffic
+     * begins. `remote_identity` can bind the ticket to a server or validator.
+     * Lifecycle event: `auth_ticket.issued`.
+     *
+     * @param title_id Title UUID.
+     * @param data Player identity, optional remote identity, and TTL.
+     */
+    static issueAuthTicket<T = MultiplayerIssueAuthTicketResponse>(title_id: string, data?: MultiplayerIssueAuthTicketRequest): AxiosPromise<Response<T>>;
+    /**
+     * Validate a multiplayer auth ticket from a trusted title/user context.
+     *
+     * Pass `consume: true` for one-time tickets to prevent replay. Dedicated
+     * servers should usually call `validateAuthTicketForServer` so they can use
+     * `server_token` instead of a title token or user JWT. Lifecycle event:
+     * `auth_ticket.validated`.
+     *
+     * @param title_id Title UUID.
+     * @param data Ticket, optional remote identity check, and consume flag.
+     */
+    static validateAuthTicket<T = MultiplayerValidateAuthTicketResponse>(title_id: string, data: MultiplayerValidateAuthTicketRequest): AxiosPromise<Response<T>>;
+    /**
+     * Validate an auth ticket as a dedicated server.
+     *
+     * This server-token endpoint lets a dedicated server admit players without
+     * holding a user JWT or title token. Pass `consume: true` to prevent replay.
+     * Lifecycle event: `auth_ticket.validated`.
+     *
+     * @param title_id Title UUID.
+     * @param server_id Server UUID.
+     * @param data Server token, player auth ticket, optional remote identity, and consume flag.
+     */
+    static validateAuthTicketForServer<T = MultiplayerValidateAuthTicketResponse>(title_id: string, server_id: string, data: MultiplayerValidateAuthTicketForServerRequest): AxiosPromise<Response<T>>;
+    /**
+     * List a player's server favorites or history entries.
+     *
+     * Use this for Steam-like favorites and recent servers tabs. Title-token
+     * clients should pass `player_id`; user JWT clients default to the user UUID.
+     *
+     * @param title_id Title UUID.
+     * @param params Optional player and favorite/history filter.
+     */
+    static listFavorites<T = MultiplayerServerFavorite[]>(title_id: string, params?: MultiplayerFavoritesParams): AxiosPromise<Response<T>>;
+    /**
+     * Add or update a favorite/history server entry for a player.
+     *
+     * Provide `server_id` for a registered Glitch server, or `host` plus
+     * `game_port` for a direct/community server. Lifecycle event:
+     * `favorite.upserted`.
+     *
+     * @param title_id Title UUID.
+     * @param data Favorite/history target and optional metadata.
+     */
+    static addFavorite<T = MultiplayerServerFavorite>(title_id: string, data: MultiplayerFavoriteRequest): AxiosPromise<Response<T>>;
+    /**
+     * Delete a player's favorite/history server entry.
+     *
+     * The SDK sends optional `player_id` as a query parameter because the shared
+     * request helper treats DELETE payloads as query params. This maps cleanly to
+     * the backend's optional player identity validation for title-token clients.
+     * Lifecycle event: `favorite.deleted`.
+     *
+     * @param title_id Title UUID.
+     * @param favorite_id Favorite/history UUID.
+     * @param params Optional player_id for title-token clients.
+     */
+    static deleteFavorite<T = MultiplayerDeleteFavoriteResponse>(title_id: string, favorite_id: string, params?: MultiplayerDeleteFavoriteParams): AxiosPromise<Response<T>>;
+}
+
+declare class ServerOperations {
+    static listDeployments<T>(params?: Record<string, any>): AxiosPromise<Response<T>>;
+    static updatePolicy<T>(title_id: string, build_id: string, data: object): AxiosPromise<Response<T>>;
+}
+
 interface Route {
     url: string;
     method: string;
@@ -8097,6 +9067,7 @@ declare class Requests {
     static get<T>(url: string, params?: Record<string, any>): AxiosPromise<Response<T>>;
     static post<T>(url: string, data: any, params?: Record<string, any>): AxiosPromise<Response<T>>;
     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 uploadBlob<T>(url: string, filename: string, blob: Blob, data?: any, params?: Record<string, any>, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void): AxiosPromise<Response<T>>;
@@ -8430,6 +9401,8 @@ declare class Glitch {
         DiscordMarketplace: typeof DiscordMarketplace;
         Education: typeof Education;
         Crm: typeof Crm;
+        Multiplayer: typeof Multiplayer;
+        ServerOperations: typeof ServerOperations;
     };
     static util: {
         Requests: typeof Requests;