@crowdedkingdoms/crowdyjs 17.1.0-test.1 → 17.2.0-dev.1

package/dist/generated/graphql.d.ts

@@ -1440,6 +1440,21 @@ export type BatchActorLookupInput = {
     /** Actor ids to look up. Each is exactly 32 ASCII characters (the UDP-wire actor id), NOT a hyphenated RFC-4122 UUID. Must be non-empty; unknown ids are silently omitted from the result. */
     uuids: Array<Scalars['String']['input']>;
 };
+/** Declare a publish: every file of the built bundle. */
+export type BeginGamePublishInput = {
+    files: Array<PublishFileInput>;
+    /** The hosting slug (claimGameHosting first). */
+    slug: Scalars['String']['input'];
+};
+/** The result of beginGamePublish: a publish id and one upload per manifest file. Upload them all, then call completeGamePublish(publishId). */
+export type BeginGamePublishResult = {
+    __typename?: 'BeginGamePublishResult';
+    /** When the upload URLs stop working. */
+    expiresAt: Scalars['DateTime']['output'];
+    publishId: Scalars['BigInt']['output'];
+    slug: Scalars['String']['output'];
+    uploads: Array<HostedGameUpload>;
+};
 /** One settlement unit of the lossless ledger: a (payer, meter, period) for a continuous meter, or one request for a request-priced meter. Amounts in micro-USD; nothing is rounded. */
 export type BillingCharge = {
     __typename?: 'BillingCharge';
@@ -1801,6 +1816,13 @@ export type ChunksByDistanceResponse = {
     /** Echo of the `skip` applied to this page, or null if none was supplied. */
     skip: Maybe<Scalars['Int']['output']>;
 };
+/** Claim (or re-assert) the hosting slug for an app. */
+export type ClaimGameHostingInput = {
+    /** The app to host. Requires manage_apps on it. */
+    appId: Scalars['BigInt']['input'];
+    /** The slug to claim. Defaults to the app slug when that is a valid DNS label. Once claimed, an app keeps its slug; pass a different one to MOVE (the old path stops serving). */
+    slug?: InputMaybe<Scalars['String']['input']>;
+};
 /** Notification received when another client sends an audio packet (voice chat). Received via the udpNotifications subscription. */
 export type ClientAudioNotification = {
     __typename?: 'ClientAudioNotification';
@@ -1980,6 +2002,14 @@ export declare enum CodeAdmissionSubjectKind {
     Code = "CODE",
     Org = "ORG"
 }
+/** The result of completeGamePublish. */
+export type CompleteGamePublishResult = {
+    __typename?: 'CompleteGamePublishResult';
+    game: HostedGame;
+    /** The CloudFront invalidation id, when one was created. */
+    invalidationId: Maybe<Scalars['String']['output']>;
+    publish: HostedGamePublish;
+};
 /** Complete a magic-link sign-in with the emailed token. */
 export type CompleteLoginLinkInput = {
     /** The one-time token from the magic-link URL. */
@@ -4919,6 +4949,81 @@ export type GroupRole = {
     /** Role display name (unique within the group). */
     roleName: Scalars['String']['output'];
 };
+/** A third-party game hosted on Crowdy Games (2026-09-13). Reached at launchUrl -- https://<games host>/<slug>/, a first-party shell page -- while its bundle executes on contentOrigin, https://<slug>.<content host>, an origin of its own. One row per app; the slug is global on the tier. */
+export type HostedGame = {
+    __typename?: 'HostedGame';
+    /** The app this slug serves. */
+    appId: Scalars['BigInt']['output'];
+    /** https://<slug>.<content host> -- the origin the game bundle runs on. The shell frames this; it is also registered as the app redirect URI so the API answers its CORS. Empty for a TAKEN_DOWN game: its objects were removed from the edge and the origin is not advertised. */
+    contentOrigin: Scalars['String']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    /** The publish currently serving, if any. */
+    currentPublishId: Maybe<Scalars['BigInt']['output']>;
+    /** https://<games host>/<slug>/ -- the public URL players use; the first-party shell; the redirect URI hosted sign-in returns to. */
+    launchUrl: Scalars['String']['output'];
+    /** Listed in the Overworld lobby and the management UI Games page. Operator-controlled (setHostedGameListing); publishing is self-serve, being listed is not. */
+    listed: Scalars['Boolean']['output'];
+    /** The app display name. */
+    name: Scalars['String']['output'];
+    /** The owning organization. */
+    orgId: Scalars['BigInt']['output'];
+    /** The owning organization name, for the shell chrome. */
+    orgName: Maybe<Scalars['String']['output']>;
+    /** The owning organization slug. */
+    orgSlug: Maybe<Scalars['String']['output']>;
+    /** When the current publish went live. */
+    publishedAt: Maybe<Scalars['DateTime']['output']>;
+    /** The hosting slug: the path on the games host and the host label on the content domain. A DNS label (lower-case letters, digits, hyphens; 1-63 chars). */
+    slug: Scalars['String']['output'];
+    status: HostedGameStatus;
+    updatedAt: Scalars['DateTime']['output'];
+};
+/** One publish of a hosted game: the manifest the developer declared and what became of it. */
+export type HostedGamePublish = {
+    __typename?: 'HostedGamePublish';
+    appId: Scalars['BigInt']['output'];
+    completedAt: Maybe<Scalars['DateTime']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    failureReason: Maybe<Scalars['String']['output']>;
+    fileCount: Scalars['Int']['output'];
+    publishId: Scalars['BigInt']['output'];
+    slug: Scalars['String']['output'];
+    state: HostedGamePublishState;
+    totalBytes: Scalars['BigInt']['output'];
+    /** Who published. */
+    userId: Scalars['BigInt']['output'];
+};
+/** Lifecycle of one publish. STAGING: upload URLs issued, objects arriving. LIVE: promoted and serving. SUPERSEDED: a later publish went live. FAILED: completion refused. ABANDONED: the developer gave up (abandonGamePublish). */
+export declare enum HostedGamePublishState {
+    Abandoned = "ABANDONED",
+    Failed = "FAILED",
+    Live = "LIVE",
+    Staging = "STAGING",
+    Superseded = "SUPERSEDED"
+}
+/** Whether a hosted game is served. LIVE: served at its launchUrl. DISABLED: switched off by its developer (setHostedGameEnabled). TAKEN_DOWN: removed by an operator; the developer cannot publish or re-enable until an operator restores it. */
+export declare enum HostedGameStatus {
+    Disabled = "DISABLED",
+    Live = "LIVE",
+    TakenDown = "TAKEN_DOWN"
+}
+/** How to upload one file of a publish: PUT the file bytes to url with exactly these headers. */
+export type HostedGameUpload = {
+    __typename?: 'HostedGameUpload';
+    /** Headers the PUT must carry exactly (content type, SHA-256 checksum, staging tag, cache-control). S3 refuses a body whose digest differs. */
+    headers: Array<HostedGameUploadHeader>;
+    /** Always PUT. */
+    method: Scalars['String']['output'];
+    /** The manifest path this URL is for. */
+    path: Scalars['String']['output'];
+    /** Presigned S3 URL; valid until BeginGamePublishResult.expiresAt. */
+    url: Scalars['String']['output'];
+};
+export type HostedGameUploadHeader = {
+    __typename?: 'HostedGameUploadHeader';
+    name: Scalars['String']['output'];
+    value: Scalars['String']['output'];
+};
 /** Copy a private library revision or immutable published common version into a project by value. */
 export type ImportCrowdyStudioProjectFileInput = {
     /** App tenant shared by the project and import source. */
@@ -5035,6 +5140,8 @@ export type MintAppTokenInput = {
 };
 export type Mutation = {
     __typename?: 'Mutation';
+    /** Give up a STAGING publish and clear its staged objects. Requires manage_apps and a SESSION token. */
+    abandonGamePublish: HostedGamePublish;
     /** Acquire a free listing: writes the entitlement row. Paid listings (price_cents > 0 or a non-free acquisition mode) are refused with FEATURE_DISABLED. Idempotent per (listing, caller). Allowed in any admission mode; in allow_list apps an unadmitted acquisition holds until the listing/author/org is admitted, at which point installPlayerCode proceeds. */
     acquirePlayerCode: PlayerCodeAcquisition;
     /** Application liveness heartbeat for the authenticated user's existing actor rows in an app. Refreshes actors.updated_at so the user stays host-eligible, then returns the freshly-elected host so a client can fold its poll and heartbeat into one round-trip. This is not proof of a live Buddy session and does not refresh the separate Buddy presence lease used by security-sensitive artifact/compute occupancy gates. */
@@ -5055,6 +5162,8 @@ export type Mutation = {
     assignGroupToGrid: Array<GridGroupGrant>;
     /** Record the user's consent for an (untrusted) app to receive app-scoped tokens via the portal. Called from the Overworld consent screen before createPortalAuthorizationCode. Idempotent. Requires a SESSION token. */
     authorizeApp: AppAuthorizationGrant;
+    /** Declare a publish: the full manifest of the built bundle (path, size, SHA-256 per file; index.html at the root). Validates it as a whole (HOSTED_MANIFEST_INVALID names every problem), records a STAGING publish, and returns one presigned PUT per file. Upload every file with exactly the returned headers, then call completeGamePublish. Rate-limited per app. Requires manage_apps and a SESSION token. */
+    beginGamePublish: BeginGamePublishResult;
     /** Begin vaulting a card on the caller's player wallet (P4b): returns a Stripe SetupIntent client secret + publishable key for the browser to confirm. On success the card is saved for wallet auto-recharge and rent auto-renew. Closes the P2 gap where players had no card-setup path. */
     beginPlayerCardSetup: PlayerCardSetup;
     /** DESTRUCTIVE. Cancels an app's paid shared-environment subscription. The app loses its paid shared slot (typically at currentPeriodEnd) and may be denied runtime once the period lapses unless a free slot covers it. Returns the updated subscription. Requires the 'manage_billing' permission on the app's org. */
@@ -5065,12 +5174,16 @@ export type Mutation = {
     changePassword: Scalars['Boolean']['output'];
     /** Self-service: the authenticated caller claims access to an app via its free, open-by-default tier. Requires authentication only (no org membership needed). ENTITLEMENT CHANGE: grants the free default tier as a 'system' grant and notifies the game API. Idempotent: returns the existing row if already granted, and never overrides a prior revoke. Errors if the app has no free default tier or is archived. */
     claimFreeAppAccess: AppUserAccess;
+    /** Claim the hosting slug for an app (idempotent; the same app re-claiming its slug is a no-op, a different slug MOVES the game). Registers https://<games host>/<slug>/ and https://<slug>.<content host> as the app's redirect URIs and sets launch_url to the former. Requires manage_apps on the app and a SESSION token. Refuses a slug that is not a DNS label, is reserved, or belongs to another app (HOSTED_SLUG_UNAVAILABLE), and answers CONTENT_HOSTING_DISABLED on a tier without a content CDN. */
+    claimGameHosting: HostedGame;
     /** Claim one currently unclaimed chunk as a new player-owned grid. Requires an ordinary app-scoped player token and active app access, but never manage_apps. The app's policy must be SELF_CLAIM. The server validates the app's grid assignment and peer-overlap rules, then atomically creates a one-chunk grid, assigns current-user ownership, grants access/update_voxel_data/use_voice_chat/teleport plus the player-code keys and use_video_chat where the caller's tier already carries them, and materializes the effective ACL. Conflicts and policy denials throw GraphQL errors; no partial grid, ownership, or grant rows remain. */
     claimGridChunk: ChunkClaimResult;
     /** Claim grid ownership under the app's claim policy (D4, server-authorized — no client manage_apps involved). SELF_CLAIM assigns ownership immediately; APPROVAL creates a pending request for designated approvers; INVITE requires a standing invite (consumed on use); MARKETPLACE_ONLY refuses. The grid must exist and have no current owner; game rules gate who may attempt a claim. */
     claimGridOwnership: GridClaimResult;
     /** Remove an app's compute allowance, returning it to observation against the platform reference allowance. Returns true if an allowance was removed. Requires app-admin ('manage_apps'). */
     clearAppComputeBudget: Scalars['Boolean']['output'];
+    /** Finish a publish: verifies every staged object against the manifest (HOSTED_PUBLISH_INCOMPLETE names what is missing), promotes the staging area to the live prefix, removes objects the previous publish left, records the publish LIVE and invalidates the content CDN. Requires manage_apps and a SESSION token. */
+    completeGamePublish: CompleteGamePublishResult;
     /** Complete a magic-link sign-in with the emailed token; returns a session AuthResponse. Public (the token authorizes the call); throws if invalid/expired/used. First-party origins only (HOSTED_SIGN_IN_REQUIRED otherwise). */
     completeLoginLink: AuthResponse;
     /** Delete a compute module and (via cascade) its versions, triggers, and lease. Run history is retained for auditing. Returns true when a module was deleted. Requires the org 'manage_compute' permission. */
@@ -5419,6 +5532,10 @@ export type Mutation = {
     setEarlyAccessOverride: User;
     /** Replace the whitelist of permission keys allowed on a grid (writes the `grid_permission_limits` input table), then recompute the grid's materialized effective ACL so any keys no longer on the whitelist are dropped for all users. Pass an empty array to remove all limits. Requires app-admin ('manage_apps'). DESTRUCTIVE: narrowing the whitelist can strip effective permissions from existing users on the grid. */
     setGridPermissionLimits: GridPermissionLimits;
+    /** Developer switch: DISABLED (the shell says "disabled by its developer") or back to LIVE. A TAKEN_DOWN game is refused (HOSTED_GAME_TAKEN_DOWN). Requires manage_apps and a SESSION token. */
+    setHostedGameEnabled: HostedGame;
+    /** OPERATOR: list or unlist a hosted game in the lobby and the management UI. */
+    setHostedGameListing: HostedGame;
     /** Adds a password to the signed-in account when it does not have one yet — for an account created by magic link or a social provider, which previously had no in-product way to add password sign-in. Requires a valid session token; the session is the proof of account control, so the password is usable immediately and no email confirmation is needed. Refuses with extensions.code PASSWORD_ALREADY_SET (409) when a password is already set — use changePassword, which verifies the current one, or the reset flow if it is forgotten. (Before v1.60.0 that refusal reached clients as INTERNAL_SERVER_ERROR while this description said CONFLICT, so a client could only recognise it by the message text.) A security notification is emailed to the account address. Existing sessions are not revoked. */
     setInitialPassword: Scalars['Boolean']['output'];
     /** Super-admin only. Flip users.is_operator to grant or revoke control-plane / operator access. */
@@ -5451,6 +5568,8 @@ export type Mutation = {
     socialLoginComplete: AuthResponse;
     /** Begin a federated (social) sign-in: returns an authorizeUrl to redirect the user to and an opaque state to round-trip back to socialLoginComplete. Public; first-party origins only (HOSTED_SIGN_IN_REQUIRED otherwise). */
     socialLoginStart: SocialLoginStart;
+    /** OPERATOR: take a hosted game down (status TAKEN_DOWN, unlisted; the shell refuses it and the developer can neither publish nor re-enable) or restore it to LIVE with takenDown=false. */
+    takeDownHostedGame: HostedGame;
     /** Checks whether the authenticated user is allowed to teleport an actor to a destination within an app and returns the authorization result. This is an authorization check only — it does NOT itself move the actor; the UDP runtime performs the actual movement. Requires a valid bearer game token plus the app-level "teleport" runtime permission. Returns success=false with errorCode INVALID_APP_ID (non-positive appId), UNAUTHORIZED (reserved sentinel destination -6,-6,-6 or missing permission), or success=true / NO_ERROR when allowed. */
     teleportRequest: TeleportResponse;
     /** Transfer grid title to another user. The current user owner or an app admin may transfer. DESTRUCTIVE/SECURITY-SENSITIVE: atomically disables every player module on the grid pending new-owner consent, wipes module state, removes the old owner direct grid grants, and closes the old title row. The new owner receives no implicit permissions. */
@@ -5508,6 +5627,10 @@ export type Mutation = {
     /** Records (upserts) a single voxel edit in the voxel_updates log for one chunk and returns the resulting Voxel. WRITES world state; a background maintenance job later folds these edits into the chunk's packed grid. Requires a valid bearer token AND voxel-edit permission for the target region: the user must have active app access, the `update_voxel_data` tier permission, and (when grids cover the chunk) `update_voxel_data` on a covering grid. */
     updateVoxel: Voxel;
 };
+export type MutationAbandonGamePublishArgs = {
+    publishId: Scalars['BigInt']['input'];
+    slug: Scalars['String']['input'];
+};
 export type MutationAcquirePlayerCodeArgs = {
     appId: Scalars['BigInt']['input'];
     listingId: Scalars['String']['input'];
@@ -5543,6 +5666,9 @@ export type MutationAssignGroupToGridArgs = {
 export type MutationAuthorizeAppArgs = {
     input: AuthorizeAppInput;
 };
+export type MutationBeginGamePublishArgs = {
+    input: BeginGamePublishInput;
+};
 export type MutationCancelSharedSubscriptionArgs = {
     appId: Scalars['BigInt']['input'];
     idempotencyKey?: InputMaybe<Scalars['String']['input']>;
@@ -5558,6 +5684,9 @@ export type MutationChangePasswordArgs = {
 export type MutationClaimFreeAppAccessArgs = {
     appId: Scalars['BigInt']['input'];
 };
+export type MutationClaimGameHostingArgs = {
+    input: ClaimGameHostingInput;
+};
 export type MutationClaimGridChunkArgs = {
     appId: Scalars['BigInt']['input'];
     chunk: ChunkCoordinatesInput;
@@ -5569,6 +5698,10 @@ export type MutationClaimGridOwnershipArgs = {
 export type MutationClearAppComputeBudgetArgs = {
     appId: Scalars['BigInt']['input'];
 };
+export type MutationCompleteGamePublishArgs = {
+    publishId: Scalars['BigInt']['input'];
+    slug: Scalars['String']['input'];
+};
 export type MutationCompleteLoginLinkArgs = {
     input: CompleteLoginLinkInput;
 };
@@ -6170,6 +6303,12 @@ export type MutationSetEarlyAccessOverrideArgs = {
 export type MutationSetGridPermissionLimitsArgs = {
     input: SetGridPermissionLimitsInput;
 };
+export type MutationSetHostedGameEnabledArgs = {
+    input: SetHostedGameEnabledInput;
+};
+export type MutationSetHostedGameListingArgs = {
+    input: SetHostedGameListingInput;
+};
 export type MutationSetInitialPasswordArgs = {
     newPassword: Scalars['String']['input'];
 };
@@ -6233,6 +6372,10 @@ export type MutationSocialLoginCompleteArgs = {
 export type MutationSocialLoginStartArgs = {
     input: SocialLoginStartInput;
 };
+export type MutationTakeDownHostedGameArgs = {
+    slug: Scalars['String']['input'];
+    takenDown?: InputMaybe<Scalars['Boolean']['input']>;
+};
 export type MutationTeleportRequestArgs = {
     input: TeleportRequestInput;
 };
@@ -7510,6 +7653,15 @@ export type PublishCrowdyStudioCommonFileInput = {
     /** Crowdy Studio-authored catalog title. */
     title: Scalars['String']['input'];
 };
+/** One file of a publish manifest. */
+export type PublishFileInput = {
+    /** Relative path inside dist/, forward slashes. index.html must be present at the root. */
+    path: Scalars['String']['input'];
+    /** Lower-case hex SHA-256 of the bytes. S3 verifies the upload against it and completeGamePublish verifies the stored object. */
+    sha256: Scalars['String']['input'];
+    /** Size in bytes. */
+    size: Scalars['Int']['input'];
+};
 export type PublishPlayerCodeInput = {
     /** App the listing belongs to. */
     appId: Scalars['BigInt']['input'];
@@ -7548,6 +7700,8 @@ export type Query = {
     actorsConnection: ActorsConnection;
     /** OPERATOR ONLY. The Crowdy Studio agent price list: every model card with its four per-million token prices and its lifecycle status. Separate from billingRateCard because agent pricing is per model rather than per metered dimension. Read-only. */
     agentRateCards: Array<AgentRateCardEntryType>;
+    /** OPERATOR: every hosted game on the tier, whatever its status or listing. */
+    allHostedGames: Array<HostedGame>;
     /** Convenience for UI: returns true when the authenticated caller is the currently elected host for the given app (same election as gameHost), otherwise false (including when no host is elected). Not authoritative for server-side mutations — use gameModelInvoke's is_host policy for that. Requires a valid bearer game token (same auth as gameHost). */
     amIGameHost: Scalars['Boolean']['output'];
     /** Fetch a single app by its numeric id. Requires authentication (any signed-in user); does NOT enforce org/app permissions, so it can read apps the caller does not own, of any visibility/status. Returns null if the id does not exist. Prefer appBySlug for slug-based marketplace lookups. */
@@ -7797,6 +7951,12 @@ export type Query = {
     gridPermissionLimits: GridPermissionLimits;
     /** Read one user's effective (materialized) runtime permission keys on a grid — the flattened union of direct and group-derived grants that Buddy enforces, with expired grants excluded. Use this to see what a user can actually do. To inspect the underlying inputs instead, use `gridGroupGrants` (group grants) and `gridPermissionLimits` (the whitelist). Requires app-admin ('manage_apps'). */
     gridUserPermissions: GridUserPermissions;
+    /** A hosted third-party game by slug, or null when the slug is unclaimed. PUBLIC: the first-party shell at https://<games host>/<slug>/ calls this before sign-in to learn the contentOrigin it frames. Returns DISABLED and TAKEN_DOWN games too (with their status) so the shell can say why. Null when the tier does not host third-party games. */
+    hostedGame: Maybe<HostedGame>;
+    /** Publish history for a hosted game, newest first. Requires manage_apps on the app and a SESSION token. */
+    hostedGamePublishes: Array<HostedGamePublish>;
+    /** The LIVE and LISTED hosted third-party games, for the Overworld lobby and the marketplace. PUBLIC. Empty when the tier does not host third-party games. Operators see every game with allHostedGames. */
+    hostedGames: Array<HostedGame>;
     /** Lists recorded voxel edits for all chunks within a cubic (Chebyshev) radius of a center chunk, grouped per chunk and ordered by increasing distance, paginated over chunks. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
     listVoxelUpdatesByDistance: VoxelUpdatesByDistanceResponse;
     /** Lists recorded voxel edits for a single chunk (optionally only those at/after `since`), newest first. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
@@ -7826,6 +7986,8 @@ export type Query = {
      * @deprecated Legacy donation/property-token data; these products are no longer purchasable. Retained for historical records.
      */
     myDonationData: UserDonationData;
+    /** The hosted games the caller can manage (manage_apps on the app). Requires a SESSION token. */
+    myHostedGames: Array<HostedGame>;
     /** The signed-in user's linked sign-in identities. */
     myIdentities: Array<UserIdentity>;
     /** Lists the authenticated caller's organization memberships. Each entry bundles the org, the caller's effective permission keys, and assigned roles. Requires a valid session token. */
@@ -8439,6 +8601,13 @@ export type QueryGridUserPermissionsArgs = {
     gridId: Scalars['BigInt']['input'];
     userId: Scalars['BigInt']['input'];
 };
+export type QueryHostedGameArgs = {
+    slug: Scalars['String']['input'];
+};
+export type QueryHostedGamePublishesArgs = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    slug: Scalars['String']['input'];
+};
 export type QueryListVoxelUpdatesByDistanceArgs = {
     input: ListVoxelUpdatesByDistanceInput;
 };
@@ -9480,6 +9649,16 @@ export type SetGridPermissionLimitsInput = {
     /** The whitelist of permission keys allowed on this grid. Empty array removes all limits (every active grid permission becomes grantable again). Each key must be a known runtime permission key, unique, and at most 64 chars. */
     permissionKeys: Array<Scalars['String']['input']>;
 };
+/** Developer: switch a hosted game off (DISABLED) or back on (LIVE). A TAKEN_DOWN game cannot be re-enabled here. */
+export type SetHostedGameEnabledInput = {
+    enabled: Scalars['Boolean']['input'];
+    slug: Scalars['String']['input'];
+};
+/** Operator: list or unlist a hosted game. */
+export type SetHostedGameListingInput = {
+    listed: Scalars['Boolean']['input'];
+    slug: Scalars['String']['input'];
+};
 /** Replace a member's roles in a group (the listed roles become their full set). */
 export type SetMemberRolesInput = {
     /** The group (team/channel) id. */
@@ -15322,6 +15501,325 @@ export type ActorHeartbeatMutation = {
         earliestActorJoinedAt: string;
     } | null;
 };
+export type HostedGameFieldsFragment = {
+    __typename?: 'HostedGame';
+    slug: string;
+    appId: string;
+    orgId: string;
+    name: string;
+    orgSlug: string | null;
+    orgName: string | null;
+    status: HostedGameStatus;
+    listed: boolean;
+    contentOrigin: string;
+    launchUrl: string;
+    currentPublishId: string | null;
+    publishedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type HostedGamePublishFieldsFragment = {
+    __typename?: 'HostedGamePublish';
+    publishId: string;
+    appId: string;
+    slug: string;
+    userId: string;
+    state: HostedGamePublishState;
+    fileCount: number;
+    totalBytes: string;
+    failureReason: string | null;
+    createdAt: string;
+    completedAt: string | null;
+};
+export type HostedGameQueryVariables = Exact<{
+    slug: Scalars['String']['input'];
+}>;
+export type HostedGameQuery = {
+    __typename?: 'Query';
+    hostedGame: {
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type HostedGamesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type HostedGamesQuery = {
+    __typename?: 'Query';
+    hostedGames: Array<{
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type AllHostedGamesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AllHostedGamesQuery = {
+    __typename?: 'Query';
+    allHostedGames: Array<{
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type MyHostedGamesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type MyHostedGamesQuery = {
+    __typename?: 'Query';
+    myHostedGames: Array<{
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type HostedGamePublishesQueryVariables = Exact<{
+    slug: Scalars['String']['input'];
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type HostedGamePublishesQuery = {
+    __typename?: 'Query';
+    hostedGamePublishes: Array<{
+        __typename?: 'HostedGamePublish';
+        publishId: string;
+        appId: string;
+        slug: string;
+        userId: string;
+        state: HostedGamePublishState;
+        fileCount: number;
+        totalBytes: string;
+        failureReason: string | null;
+        createdAt: string;
+        completedAt: string | null;
+    }>;
+};
+export type ClaimGameHostingMutationVariables = Exact<{
+    input: ClaimGameHostingInput;
+}>;
+export type ClaimGameHostingMutation = {
+    __typename?: 'Mutation';
+    claimGameHosting: {
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type BeginGamePublishMutationVariables = Exact<{
+    input: BeginGamePublishInput;
+}>;
+export type BeginGamePublishMutation = {
+    __typename?: 'Mutation';
+    beginGamePublish: {
+        __typename?: 'BeginGamePublishResult';
+        publishId: string;
+        slug: string;
+        expiresAt: string;
+        uploads: Array<{
+            __typename?: 'HostedGameUpload';
+            path: string;
+            url: string;
+            method: string;
+            headers: Array<{
+                __typename?: 'HostedGameUploadHeader';
+                name: string;
+                value: string;
+            }>;
+        }>;
+    };
+};
+export type CompleteGamePublishMutationVariables = Exact<{
+    slug: Scalars['String']['input'];
+    publishId: Scalars['BigInt']['input'];
+}>;
+export type CompleteGamePublishMutation = {
+    __typename?: 'Mutation';
+    completeGamePublish: {
+        __typename?: 'CompleteGamePublishResult';
+        invalidationId: string | null;
+        game: {
+            __typename?: 'HostedGame';
+            slug: string;
+            appId: string;
+            orgId: string;
+            name: string;
+            orgSlug: string | null;
+            orgName: string | null;
+            status: HostedGameStatus;
+            listed: boolean;
+            contentOrigin: string;
+            launchUrl: string;
+            currentPublishId: string | null;
+            publishedAt: string | null;
+            createdAt: string;
+            updatedAt: string;
+        };
+        publish: {
+            __typename?: 'HostedGamePublish';
+            publishId: string;
+            appId: string;
+            slug: string;
+            userId: string;
+            state: HostedGamePublishState;
+            fileCount: number;
+            totalBytes: string;
+            failureReason: string | null;
+            createdAt: string;
+            completedAt: string | null;
+        };
+    };
+};
+export type AbandonGamePublishMutationVariables = Exact<{
+    slug: Scalars['String']['input'];
+    publishId: Scalars['BigInt']['input'];
+}>;
+export type AbandonGamePublishMutation = {
+    __typename?: 'Mutation';
+    abandonGamePublish: {
+        __typename?: 'HostedGamePublish';
+        publishId: string;
+        appId: string;
+        slug: string;
+        userId: string;
+        state: HostedGamePublishState;
+        fileCount: number;
+        totalBytes: string;
+        failureReason: string | null;
+        createdAt: string;
+        completedAt: string | null;
+    };
+};
+export type SetHostedGameEnabledMutationVariables = Exact<{
+    input: SetHostedGameEnabledInput;
+}>;
+export type SetHostedGameEnabledMutation = {
+    __typename?: 'Mutation';
+    setHostedGameEnabled: {
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type SetHostedGameListingMutationVariables = Exact<{
+    input: SetHostedGameListingInput;
+}>;
+export type SetHostedGameListingMutation = {
+    __typename?: 'Mutation';
+    setHostedGameListing: {
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type TakeDownHostedGameMutationVariables = Exact<{
+    slug: Scalars['String']['input'];
+    takenDown?: InputMaybe<Scalars['Boolean']['input']>;
+}>;
+export type TakeDownHostedGameMutation = {
+    __typename?: 'Mutation';
+    takeDownHostedGame: {
+        __typename?: 'HostedGame';
+        slug: string;
+        appId: string;
+        orgId: string;
+        name: string;
+        orgSlug: string | null;
+        orgName: string | null;
+        status: HostedGameStatus;
+        listed: boolean;
+        contentOrigin: string;
+        launchUrl: string;
+        currentPublishId: string | null;
+        publishedAt: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
 export type PlayerCodeListingFieldsFragment = {
     __typename?: 'PlayerCodeListing';
     listingId: string;
@@ -18851,6 +19349,8 @@ export declare const GmContainerFieldsFragmentDoc: DocumentNode<GmContainerField
 export declare const GmInvokeResultFieldsFragmentDoc: DocumentNode<GmInvokeResultFieldsFragment, unknown>;
 export declare const GmFunctionFieldsFragmentDoc: DocumentNode<GmFunctionFieldsFragment, unknown>;
 export declare const GmPropertyDefFieldsFragmentDoc: DocumentNode<GmPropertyDefFieldsFragment, unknown>;
+export declare const HostedGameFieldsFragmentDoc: DocumentNode<HostedGameFieldsFragment, unknown>;
+export declare const HostedGamePublishFieldsFragmentDoc: DocumentNode<HostedGamePublishFieldsFragment, unknown>;
 export declare const PlayerCodeListingFieldsFragmentDoc: DocumentNode<PlayerCodeListingFieldsFragment, unknown>;
 export declare const PlayerCodeListingVersionFieldsFragmentDoc: DocumentNode<PlayerCodeListingVersionFieldsFragment, unknown>;
 export declare const PlayerCodeAcquisitionFieldsFragmentDoc: DocumentNode<PlayerCodeAcquisitionFieldsFragment, unknown>;
@@ -19053,6 +19553,18 @@ export declare const GameModelRevokeTierFeatureDocument: DocumentNode<GameModelR
 export declare const GameHostDocument: DocumentNode<GameHostQuery, GameHostQueryVariables>;
 export declare const AmIGameHostDocument: DocumentNode<AmIGameHostQuery, AmIGameHostQueryVariables>;
 export declare const ActorHeartbeatDocument: DocumentNode<ActorHeartbeatMutation, ActorHeartbeatMutationVariables>;
+export declare const HostedGameDocument: DocumentNode<HostedGameQuery, HostedGameQueryVariables>;
+export declare const HostedGamesDocument: DocumentNode<HostedGamesQuery, HostedGamesQueryVariables>;
+export declare const AllHostedGamesDocument: DocumentNode<AllHostedGamesQuery, AllHostedGamesQueryVariables>;
+export declare const MyHostedGamesDocument: DocumentNode<MyHostedGamesQuery, MyHostedGamesQueryVariables>;
+export declare const HostedGamePublishesDocument: DocumentNode<HostedGamePublishesQuery, HostedGamePublishesQueryVariables>;
+export declare const ClaimGameHostingDocument: DocumentNode<ClaimGameHostingMutation, ClaimGameHostingMutationVariables>;
+export declare const BeginGamePublishDocument: DocumentNode<BeginGamePublishMutation, BeginGamePublishMutationVariables>;
+export declare const CompleteGamePublishDocument: DocumentNode<CompleteGamePublishMutation, CompleteGamePublishMutationVariables>;
+export declare const AbandonGamePublishDocument: DocumentNode<AbandonGamePublishMutation, AbandonGamePublishMutationVariables>;
+export declare const SetHostedGameEnabledDocument: DocumentNode<SetHostedGameEnabledMutation, SetHostedGameEnabledMutationVariables>;
+export declare const SetHostedGameListingDocument: DocumentNode<SetHostedGameListingMutation, SetHostedGameListingMutationVariables>;
+export declare const TakeDownHostedGameDocument: DocumentNode<TakeDownHostedGameMutation, TakeDownHostedGameMutationVariables>;
 export declare const MarketplaceListingsDocument: DocumentNode<MarketplaceListingsQuery, MarketplaceListingsQueryVariables>;
 export declare const MarketplaceListingVersionsDocument: DocumentNode<MarketplaceListingVersionsQuery, MarketplaceListingVersionsQueryVariables>;
 export declare const MarketplaceMyAcquisitionsDocument: DocumentNode<MarketplaceMyAcquisitionsQuery, MarketplaceMyAcquisitionsQueryVariables>;