@crowdedkingdoms/crowdyjs 7.1.1 → 8.0.1

package/dist/generated/graphql.d.ts

@@ -185,6 +185,8 @@ export type App = {
     __typename?: 'App';
     /** Unique numeric identifier of the app (primary key). */
     appId: Scalars['BigInt']['output'];
+    /** OAuth client type: "public" (browser/PKCE, no secret) or "confidential" (server-side, holds a secret). Defaults to "public". */
+    clientType: Scalars['String']['output'];
     /** Timestamp when the app was created. */
     createdAt: Scalars['DateTime']['output'];
     /** Numeric user id of the account that created the app. */
@@ -195,6 +197,10 @@ export type App = {
     description: Maybe<Scalars['String']['output']>;
     /** Resolved game-api base URL for SDK/runtime calls: the per-tenant URL for dedicated apps, or the shared platform URL for shared apps. Null for legacy or not-yet-deployed apps. */
     gameApiUrl: Maybe<Scalars['String']['output']>;
+    /** True for first-party/trusted apps: portal entry skips the consent screen. The Overworld (app 1) is trusted. Studio admins cannot set this; it is platform-controlled. */
+    isTrusted: Scalars['Boolean']['output'];
+    /** Browser destination (origin/URL) a player is redirected to when they portal into this app from the Overworld. Used to route the player and to validate portal redirect URIs. */
+    launchUrl: Maybe<Scalars['String']['output']>;
     /** Opaque JSON-encoded string of marketplace media (cover image URL, screenshots, long description, etc.). Stored internally as JSONB; clients must JSON.parse on read and JSON.stringify on write. Null/"{}" when unset. */
     metadata: Maybe<Scalars['String']['output']>;
     /** Human-readable display name of the app. */
@@ -203,6 +209,10 @@ export type App = {
     org: Maybe<Organization>;
     /** Numeric id of the organization that owns this app. */
     orgId: Scalars['BigInt']['output'];
+    /** OAuth-style redirect-URI allow-list for the portal handoff. A portal authorization code’s redirect_uri must match one of these by origin; empty disallows browser portal entry to this app. */
+    redirectUris: Array<Scalars['String']['output']>;
+    /** Reserved sustained egress in bytes/s for shared apps. 0 = free tier; >0 bypasses the ~1 MB/s rate limit and incurs a monthly reservation fee. */
+    reservedEgressBytesPerSec: Scalars['BigInt']['output'];
     /** When runtimeStatus is not "active", why the runtime is gated: "free_allowance", "insufficient_funds", "spend_cap", or "subscription_lapsed". Null when active. */
     runtimeDenialReason: Maybe<Scalars['String']['output']>;
     /** Shared-environment runtime gate, mirrored to the game DB and enforced by game-api + Buddy: "active", "grace", "denied", or "suspended". */
@@ -252,6 +262,20 @@ export type AppAccessTier = {
     /** Timestamp when the tier was last updated. */
     updatedAt: Scalars['DateTime']['output'];
 };
+/** A user's standing consent for an app to receive app-scoped tokens via the Overworld portal (the “connected apps” list). */
+export type AppAuthorizationGrant = {
+    __typename?: 'AppAuthorizationGrant';
+    appId: Scalars['ID']['output'];
+    appName: Maybe<Scalars['String']['output']>;
+    grantId: Scalars['ID']['output'];
+    grantedAt: Scalars['DateTime']['output'];
+    revokedAt: Maybe<Scalars['DateTime']['output']>;
+    /** The scopes the user approved for this app. */
+    scopes: Array<Scalars['String']['output']>;
+    /** 'active' | 'revoked'. */
+    status: Scalars['String']['output'];
+    userId: Scalars['ID']['output'];
+};
 export type AppAvatarState = {
     __typename?: 'AppAvatarState';
     /** App (game) id this state is scoped to. BigInt serialized as a decimal string. */
@@ -387,7 +411,7 @@ export type AppSharedSubscription = {
 export declare enum AppStatus {
     /** Soft-deleted via archiveApp: retained but read-only and excluded from the marketplace. Reversible by setting status back to DRAFT or LIVE. */
     Archived = "ARCHIVED",
-    /** Work-in-progress: invisible to non-members and never listed in the marketplace. Default for newly created apps. */
+    /** Work-in-progress: invisible to non-members and never listed in the marketplace. Selectable manually via updateApp; new apps default to LIVE. */
     Draft = "DRAFT",
     /** Published and purchasable/playable; eligible for the public marketplace when visibility=PUBLIC. */
     Live = "LIVE"
@@ -410,6 +434,26 @@ export type AppTokenResponse = {
     /** Opaque app-scoped gameplay token. Send to the target app's Game API as `Authorization: Bearer <token>` (and in the realtime `connectionParams`). Do NOT send it to the Management API for anything other than `me`/`refreshAppToken`. */
     token: Scalars['String']['output'];
 };
+/** End-of-month egress projection for one shared app from linear extrapolation of calendar-month usage so far. */
+export type AppUsageProjection = {
+    __typename?: 'AppUsageProjection';
+    /** App id (as a string). */
+    appId: Scalars['String']['output'];
+    /** Egress bytes recorded so far this calendar month (from app_monthly_egress). */
+    currentEgressBytes: Scalars['String']['output'];
+    /** Fractional UTC days elapsed since the calendar month started. */
+    daysElapsed: Scalars['Float']['output'];
+    /** Per-app free monthly egress allowance in bytes (5 decimal GB). */
+    freeAllowanceBytes: Scalars['String']['output'];
+    /** True when projected egress exceeds the free allowance, or null when insufficient data. */
+    onTrackToExceed: Maybe<Scalars['Boolean']['output']>;
+    /** Projected end-of-month egress bytes (linear extrapolation), or null when insufficient data. */
+    projectedBytes: Maybe<Scalars['String']['output']>;
+    /** Projected usage as a percentage of the free allowance, or null when insufficient data. */
+    projectedPctOfFree: Maybe<Scalars['Float']['output']>;
+    /** True when at least 3 days have elapsed in the month (projection is meaningful). */
+    sufficientData: Scalars['Boolean']['output'];
+};
 /** Aggregate byte totals for one app over the requested window. All *Bytes fields are string counters (may exceed Int range). */
 export type AppUsageRollupRow = {
     __typename?: 'AppUsageRollupRow';
@@ -538,6 +582,12 @@ export type AssignGroupToGridInput = {
     /** Runtime permission key strings to grant to the group/role. Each must be a known key in runtime_permissions, unique, and at most 64 chars. */
     permissionKeys: Array<Scalars['String']['input']>;
 };
+/** Whether the account has a password set. Does not reveal whether the email is registered. */
+export type AuthMethodResult = {
+    __typename?: 'AuthMethodResult';
+    /** True when the account exists and has a password hash; false otherwise (including unknown emails). */
+    hasPassword: Scalars['Boolean']['output'];
+};
 /** Result of a successful login or registration: a session token plus the authenticated user. */
 export type AuthResponse = {
     __typename?: 'AuthResponse';
@@ -548,6 +598,13 @@ export type AuthResponse = {
     /** The authenticated user. */
     user: User;
 };
+/** Approve (consent to) an app receiving app-scoped tokens via the Overworld portal. */
+export type AuthorizeAppInput = {
+    /** App to authorize. */
+    appId: Scalars['BigInt']['input'];
+    /** Optional explicit scopes to grant (defaults to the app baseline). */
+    scopes?: InputMaybe<Array<Scalars['String']['input']>>;
+};
 export type Avatar = {
     __typename?: 'Avatar';
     /** Avatar id and primary key (auto-increment). Serialized as a GraphQL ID (a numeric string). */
@@ -642,6 +699,11 @@ export type ChannelMessageNotification = {
     /** The sending actor's UUID. */
     uuid: Scalars['String']['output'];
 };
+/** Check whether an account has password sign-in enabled (email-first adaptive login). */
+export type CheckAuthMethodInput = {
+    /** Email address to check. */
+    email: Scalars['String']['input'];
+};
 export type Checkout = {
     __typename?: 'Checkout';
     /** Charge amount in minor currency units (cents) of `currency`, as a BigInt decimal string; null when the purpose carries no amount. */
@@ -936,6 +998,8 @@ export type CksEnvironment = {
     graphqlBillingTier: Maybe<Scalars['Int']['output']>;
     /** Opaque environment UUID (cks_environments.id). */
     id: Scalars['String']['output'];
+    /** True for the single platform-owned shared environment (slug 'shared') that hosts the shared game-api serving apps with deploymentTarget='shared'. Customer environments are always false. */
+    isShared: Scalars['Boolean']['output'];
     loadBalancerCount: Scalars['Int']['output'];
     /** Release version actually observed running. Lags desiredEnvironmentVersion while a deploy is in progress. */
     observedEnvironmentVersion: Maybe<Scalars['String']['output']>;
@@ -1275,6 +1339,11 @@ export type ClientTextPacketInput = {
     /** A unique identifier for the text source (typically the player UUID). Must be exactly 32 bytes when encoded as UTF-8. */
     uuid: Scalars['String']['input'];
 };
+/** Complete a magic-link sign-in with the emailed token. */
+export type CompleteLoginLinkInput = {
+    /** The one-time token from the magic-link URL. */
+    token: Scalars['String']['input'];
+};
 /** Relay-style pagination metadata for a connection. */
 export type ConnectionPageInfo = {
     __typename?: 'ConnectionPageInfo';
@@ -1586,7 +1655,7 @@ export type CreateAppInput = {
     orgId: Scalars['BigInt']['input'];
     /** URL-safe slug (1-128 chars, lowercase letters, numbers and dashes only). Must be unique within the org. */
     slug: Scalars['String']['input'];
-    /** Optional initial lifecycle status. Defaults to DRAFT when omitted. */
+    /** Optional initial lifecycle status. Defaults to LIVE when omitted. */
     status?: InputMaybe<AppStatus>;
     /** Optional initial visibility. Defaults to PUBLIC when omitted. */
     visibility?: InputMaybe<AppVisibility>;
@@ -1677,6 +1746,8 @@ export type CreateEnvironmentInput = {
     gameApiMinServers?: InputMaybe<Scalars['Int']['input']>;
     /** GraphQL billing tier level from graphqlBillingTiers. Defaults to tier 1 for dedicated environments. */
     graphqlBillingTier?: InputMaybe<Scalars['Int']['input']>;
+    /** Super-admin only: designate this as the single platform-owned shared environment (slug 'shared') that hosts the shared game-api for apps with deploymentTarget='shared'. Must be a dedicated environment. Customers cannot set this; the management API rejects it for non-super-admins. */
+    isShared?: InputMaybe<Scalars['Boolean']['input']>;
     /** Number of Caddy load-balancer VMs in front of the game-api fleet (min 1). Required for dedicated; ignored for dev_single. */
     loadBalancerCount?: InputMaybe<Scalars['Int']['input']>;
     /** Organization id (BigInt) that will own and be billed for the environment. */
@@ -1817,6 +1888,11 @@ export type DestroyEnvironmentInput = {
     /** Slug of the environment to destroy (all cloud resources are torn down). */
     slug: Scalars['String']['input'];
 };
+/** Dev-only bypass sign-in (active only when DEV_AUTH_BYPASS is enabled; never in production). */
+export type DevLoginInput = {
+    /** Email of the account to sign in as (created if absent). */
+    email: Scalars['String']['input'];
+};
 /** Input for environmentQuote. Mirrors CreateEnvironmentInput’s class/flavor shape: dedicated needs the four per-role flavors + counts; dev_single needs only the single flavor. */
 export type EnvironmentQuoteInput = {
     /** Flavor name from environmentFlavors(datacenter) for the Caddy LB VMs in front of the game-api fleet; must have a published hourly price. Required for dedicated. */
@@ -1887,6 +1963,8 @@ export type ExchangePortalCodeInput = {
 /** An org's free shared app slot quota usage. */
 export type FreeAppQuota = {
     __typename?: 'FreeAppQuota';
+    /** Shared apps with free-slot / reserved / paid credit status. */
+    apps: Array<FreeAppQuotaApp>;
     /** Organization id (BigInt). */
     orgId: Scalars['BigInt']['output'];
     /** Apps on a paid subscription (do not consume free slots). */
@@ -1895,9 +1973,29 @@ export type FreeAppQuota = {
     quota: Scalars['Int']['output'];
     /** Free slots still available (quota − usedFree). */
     remainingFree: Scalars['Int']['output'];
+    /** Apps with reserved throughput (premium; do not consume free slots). */
+    reservedApps: Scalars['Int']['output'];
     /** Free slots currently in use. */
     usedFree: Scalars['Int']['output'];
 };
+/** A shared app row in the org free-slot portfolio (free / reserved / paid credit). */
+export type FreeAppQuotaApp = {
+    __typename?: 'FreeAppQuotaApp';
+    /** App id (BigInt). */
+    appId: Scalars['BigInt']['output'];
+    /** True when the app consumes a free org slot (shared, not archived, no active subscription, no reserved throughput). */
+    consumesFreeSlot: Scalars['Boolean']['output'];
+    /** How this app is credited: 'free_slot', 'reserved', or 'paid_subscription'. */
+    creditKind: Scalars['String']['output'];
+    /** True when the app has an active legacy shared subscription. */
+    hasActiveSubscription: Scalars['Boolean']['output'];
+    /** App display name. */
+    name: Scalars['String']['output'];
+    /** Reserved egress throughput in bytes/sec (0 when none). */
+    reservedEgressBytesPerSec: Scalars['BigInt']['output'];
+    /** URL slug for the app. */
+    slug: Scalars['String']['output'];
+};
 /** Status of the recurring free-play window during which gameplay is open without entitlement. */
 export type FreePlayWindowInfo = {
     __typename?: 'FreePlayWindowInfo';
@@ -2851,6 +2949,12 @@ export type LinkAppToEnvironmentInput = {
     /** Organization id (BigInt) that owns both the app and the environment. */
     orgId: Scalars['BigInt']['input'];
 };
+/** Link an additional federated identity to the signed-in account. */
+export type LinkIdentityInput = {
+    code: Scalars['String']['input'];
+    provider: Scalars['String']['input'];
+    state: Scalars['String']['input'];
+};
 /** Arguments for listVoxelUpdatesByDistance: selects recorded voxel edits across chunks within a cubic (Chebyshev) radius of a center chunk, grouped per chunk and ordered by increasing distance. */
 export type ListVoxelUpdatesByDistanceInput = {
     /** Id of the app whose voxel edits to search (decimal string). */
@@ -2915,6 +3019,8 @@ export type Mutation = {
     archiveApp: App;
     /** Grant runtime permission keys to a group (optionally scoped to a single group role) on a grid by writing the `grid_group_grants` input table, then recompute the materialized effective ACL so every affected member gains the keys. Requires app-admin ('manage_apps'). Returns the grid's current group grants for the group. Use `grantGridPermissions` for per-user grants instead. */
     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;
     /** 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. */
     cancelSharedSubscription: AppSharedSubscription;
     /** Captures an approved PayPal order after the hosted checkout redirects back, completes the checkout (wallet credit / access grant), and returns the updated Checkout. PayPal webhooks remain a backup for idempotent reconciliation if they arrive later. Requires an authenticated user who owns the checkout. */
@@ -2923,7 +3029,9 @@ 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;
-    /** Confirms a user email address using the token from the confirmation email. Returns true on success, false if the token is invalid or expired. Public (the token authorizes the call). */
+    /** 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. */
+    completeLoginLink: AuthResponse;
+    /** Confirms a user email address using the token from the confirmation email (also enables password sign-in for the account). Returns true on success, false if the token is invalid or expired. Public (the token authorizes the call). */
     confirmEmail: Scalars['Boolean']['output'];
     /** Open the UDP proxy session for this game token (idempotent: returns the existing status if one is already open). Binds a socket and selects the game server with the fewest clients on first open. Optional: send mutations and udpNotifications also create a session lazily when none exists. To force a fresh socket, call disconnectUdpProxy first. */
     connectUdpProxy: UdpProxyConnectionStatus;
@@ -2983,6 +3091,8 @@ export type Mutation = {
     deleteUserAppState: UserAppState;
     /** DESTRUCTIVE and IRREVERSIBLE. Tears down all cloud resources for the environment (per-tenant Postgres, game-api, Buddy, and load-balancer VMs plus DNS records) and revokes its service tokens; all tenant data is lost. Sets status to 'destroy_requested' and returns the tracking change order — poll orgEnvironment.destroyProgress. Fails if a destroy is already queued. After it reaches 'destroyed', call purgeEnvironment to remove the record. Requires the 'manage_environments' org permission. */
     destroyEnvironment: CksEnvironmentChangeOrder;
+    /** DEV ONLY bypass sign-in: returns a session for the given email without email/social verification. Active only when DEV_AUTH_BYPASS is enabled; throws (FORBIDDEN) otherwise. Never enabled in production. */
+    devLogin: AuthResponse;
     /** Close the UDP proxy session and socket for this game token. Unsubscribing from udpNotifications does not disconnect; use this mutation (or rely on server inactivity timeout). */
     disconnectUdpProxy: Scalars['Boolean']['output'];
     /** Exchange a one-time portal authorization code (with the matching PKCE verifier) for an app-scoped gameplay token. Public (the code + verifier authorize the call); called by the destination game at its own origin so the game never sees the player's session token. */
@@ -3001,8 +3111,16 @@ export type Mutation = {
     gameModelDeleteAutomation: Scalars['Boolean']['output'];
     /** Delete an automation event trigger by id. Requires app-admin ('manage_apps'). Returns true if one was deleted. */
     gameModelDeleteAutomationTrigger: Scalars['Boolean']['output'];
+    /** Delete a container instance. Cascades its instance properties and any edges connected to it. Allowed for an app admin or the container owner. Requires a valid token. DESTRUCTIVE. Returns true if a container was deleted. */
+    gameModelDeleteContainer: Scalars['Boolean']['output'];
+    /** Delete a container type. Also deletes its property definitions. Refuses if live containers of that type exist, or if functions are bound to it — delete those first. Requires app-admin ('manage_apps'). DESTRUCTIVE. Returns true if a type was deleted. */
+    gameModelDeleteContainerType: Scalars['Boolean']['output'];
+    /** Delete a directed relationship edge between two containers. Allowed for an app admin or the owner of the source (from) container. Requires a valid token. DESTRUCTIVE. Returns true if an edge was deleted. */
+    gameModelDeleteEdge: Scalars['Boolean']['output'];
     /** Delete a studio-defined function by name. Requires app-admin ('manage_apps'). DESTRUCTIVE. Returns true if a function was deleted. */
     gameModelDeleteFunction: Scalars['Boolean']['output'];
+    /** Delete a property definition from a container type. Does not remove instance property values already stored on containers. Requires app-admin ('manage_apps'). DESTRUCTIVE. Returns true if a definition was deleted. */
+    gameModelDeletePropertyDef: Scalars['Boolean']['output'];
     /** Grant a feature key to an access tier, so users on that tier satisfy tier_feature authority checks for it. Requires app-admin ('manage_apps'). */
     gameModelGrantTierFeature: GmTierFeature;
     /** Invoke a studio-defined function against a 'self' container with JSON params. The server enforces the function's invoke policy (authority rule tree: owner_of_self / is_host / is_current_turn / is_participant / tier_feature / group_permission / grid_permission / condition), evaluates its expressions, atomically applies its declared property mutations, logs an event, and returns the result (return value + mutations applied, or success=false with an error message). This is the primary, safe way for players to mutate game state. Requires a valid token; only player-scope functions are invocable here. */
@@ -3055,11 +3173,13 @@ export type Mutation = {
     leaveTeam: Scalars['Boolean']['output'];
     /** Links an unlinked app to an existing environment for split-mode routing. Refuses shared apps and apps already linked elsewhere. Requires the 'manage_environments' org permission. */
     linkAppToEnvironment: App;
-    /** Authenticates with email + password and starts a new session. Returns an AuthResponse whose `token` must be sent on subsequent requests as `Authorization: Bearer <token>`. Public (no auth required); throws on invalid credentials. */
+    /** Link an additional federated identity (from a socialLoginStart callback) to the signed-in account. Requires a session token; throws if the identity is already linked to another account. */
+    linkIdentity: UserIdentity;
+    /** Authenticates with email + password and starts a new session. Returns an AuthResponse whose `token` must be sent on subsequent requests as `Authorization: Bearer <token>`. Public (no auth required); throws on invalid credentials. If the account also has another verified sign-in method, the password must first be email-confirmed. */
     login: AuthResponse;
     /** Single-device logout: revokes the game token that authenticated this request by deleting its game_tokens row. Returns true if a token was revoked, false if the request had no game token. Other devices/tokens are unaffected (use the Management API to revoke all devices). After this, the bearer token is rejected and any open UDP proxy session will no longer authorize new traffic. */
     logout: Scalars['Boolean']['output'];
-    /** Ends every active session for the authenticated user (deletes all their game_tokens and records revocations). Requires a valid session token. Use logout to end only the current session. */
+    /** Ends every active session for the authenticated user (deletes all their game_tokens and records revocations). Requires a valid session token. */
     logoutAllDevices: Scalars['Boolean']['output'];
     /** Mint a short-lived, app-scoped gameplay token for the calling user (native/direct path; no browser redirect). Requires an identity SESSION token (app tokens cannot mint). Free/open apps auto-grant access; paid apps require an existing entitlement (else FORBIDDEN). Side effect: may create an app_user_access row on the app's free default tier. */
     mintAppToken: AppTokenResponse;
@@ -3077,7 +3197,7 @@ export type Mutation = {
     redeployEnvironment: CksEnvironmentChangeOrder;
     /** Rotate the calling app token for a fresh one (same app, extended TTL) and revoke the old. Call before the current token expires to keep playing without bouncing back through the Overworld. Allowed for app-scoped tokens; re-checks entitlement. */
     refreshAppToken: AppTokenResponse;
-    /** Creates a new (initially unconfirmed) account, sends a confirmation email, and returns an AuthResponse with a session `token` for immediate login (send as `Authorization: Bearer <token>`). Public; throws if the email already exists. */
+    /** Registers a new email + password account: creates the (initially unconfirmed) account, emails a confirmation link, and returns an AuthResponse with a session `token` for immediate use (send as `Authorization: Bearer <token>`). If an account already exists for the email (e.g. created via magic link/social), the password is attached pending email confirmation and no session is returned (throws CONFLICT). Public. */
     register: AuthResponse;
     /** Remove a member from a channel. Requires the 'manage_members' channel permission, except that any member may remove themselves. Notifies Buddy to stop routing to the removed member. Returns true if a membership was removed. */
     removeChannelMember: Scalars['Boolean']['output'];
@@ -3087,7 +3207,9 @@ export type Mutation = {
     removeSharedPaymentMethod: Scalars['Boolean']['output'];
     /** Remove a member from a team. Requires the 'manage_members' team permission, except that any member may remove themselves. DESTRUCTIVE: drops the membership and its roles. Returns true if a membership was removed. */
     removeTeamMember: Scalars['Boolean']['output'];
-    /** Starts the password-reset flow by emailing a reset link to the address. Always returns true regardless of whether the email exists or is confirmed (prevents account enumeration). Public. */
+    /** Passwordless: email a one-time magic sign-in link to the address (creates the account on first sign-in). Always reports sent=true (no account enumeration). Public. */
+    requestLoginLink: RequestLoginLinkResult;
+    /** Starts the password-reset flow by emailing a reset link to the address. Always returns true regardless of whether the email exists (prevents account enumeration). The reset link is also the ownership-proven way an existing passwordless account adds a password. Public. */
     requestPasswordReset: Scalars['Boolean']['output'];
     /** Request to join a request-only channel (creates a pending membership a manager can approve via addChannelMember). Behaves identically to joinChannel; named for request-policy UIs. */
     requestToJoinChannel: GroupMember;
@@ -3103,6 +3225,8 @@ export type Mutation = {
     resumeEnvironment: CksEnvironmentChangeOrder;
     /** Revoke a user's access to an app by setting their app_user_access status to 'revoked', and notifies the game API so the user immediately loses runtime access in Buddy. Requires the 'manage_access_tiers' permission on the app; super admins bypass. The row is retained for audit (not deleted); REVERSIBLE via grantAppAccess. */
     revokeAppAccess: AppUserAccess;
+    /** Revoke a previously-granted app authorization and immediately revoke the user's live app tokens for it. Requires a SESSION token. */
+    revokeAppAuthorization: Scalars['Boolean']['output'];
     /** Revoke a user's direct grants on a grid (deletes from the `grid_user_direct_grants` input table) and recompute their materialized effective ACL. Omit `permissionKeys` to remove ALL of the user's direct grants on the grid; pass a subset to remove only those keys. Does not affect permissions the user receives via group grants. Requires app-admin ('manage_apps'). DESTRUCTIVE for the targeted grants. Returns the user's remaining effective permission keys on the grid. */
     revokeGridPermissions: GridUserPermissions;
     /** Revoke group/role grants on a grid (deletes from the `grid_group_grants` input table) and recompute the materialized effective ACL. Omit `permissionKeys` to revoke ALL of the group/role's grants on the grid; pass a subset to revoke only those keys. Requires app-admin ('manage_apps'). DESTRUCTIVE: removes the granted permissions from every affected member. Returns the group's remaining grants on the grid. */
@@ -3111,7 +3235,7 @@ export type Mutation = {
     revokeOrgToken: Scalars['Boolean']['output'];
     /** Reverts every voxel edit made by `userId` in `appId` between `from` and `to`, returning one RollbackVoxelEventResult per affected voxel (`applied` tells you whether each was actually changed). DEFAULTS to dryRun=true, which only PREVIEWS the planned reversions without writing; pass dryRun=false to actually apply them (DESTRUCTIVE — mutates world state). Requires a valid bearer token AND the `manage_apps` permission on the org that owns `appId` (super admins bypass). */
     rollbackVoxelUpdates: Array<RollbackVoxelEventResult>;
-    /** Send an actor (player/NPC) state update for spatial replication to nearby chunks. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — it does NOT confirm the world applied the update. The applied echo (ActorUpdateResponse) and any failure (GenericErrorResponse) arrive ASYNCHRONOUSLY on the udpNotifications subscription, correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). Subscribe to udpNotifications before sending so the reply is not missed. */
+    /** Send an actor (player/NPC) state update for spatial replication to nearby chunks. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — it does NOT confirm the world applied the update. There is NO separate per-request success response: the game server fans the update out to every client in the target chunk INCLUDING the sender, so you observe your own applied update as an ActorUpdateNotification carrying the same sequenceNumber (ActorUpdateResponse is legacy and is never emitted). Failures arrive ASYNCHRONOUSLY as a GenericErrorResponse; both are correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). Subscribe to udpNotifications before sending so the self-notification/error is not missed. */
     sendActorUpdate: Scalars['Boolean']['output'];
     /** Send a spatial voice/audio packet, fanned out to nearby actors as a ClientAudioNotification. Requires a bearer game token; voice may additionally be gated by a runtime/grid permission for the region — if the caller lacks it the game server responds asynchronously with a GenericErrorResponse (errorCode UNAUTHORIZED). Opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING — NOT that it was delivered; the sender receives no echo, only errors (GenericErrorResponse, correlated by sequenceNumber) on udpNotifications. sequenceNumber is correlation only, not an idempotency key. */
     sendAudioPacket: Scalars['Boolean']['output'];
@@ -3123,10 +3247,14 @@ export type Mutation = {
     sendSingleActorMessage: Scalars['Boolean']['output'];
     /** Send a spatial text/chat packet, fanned out to nearby actors as a ClientTextNotification. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — NOT confirmation of delivery. The sender receives no echo; failures arrive ASYNCHRONOUSLY as GenericErrorResponse on udpNotifications, correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
     sendTextPacket: Scalars['Boolean']['output'];
-    /** Send a single voxel (block) update for spatial replication to nearby chunks. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — NOT confirmation that the world applied the change. The applied echo (VoxelUpdateResponse) and any failure (GenericErrorResponse) arrive ASYNCHRONOUSLY on udpNotifications, correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
+    /** Send a single voxel (block) update for spatial replication to nearby chunks. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — NOT confirmation that the world applied the change. There is NO separate per-request success response: the change fans out to nearby clients (the sender included) as a VoxelUpdateNotification carrying the same sequenceNumber (VoxelUpdateResponse is legacy and is never emitted). Failures arrive ASYNCHRONOUSLY as a GenericErrorResponse; both are correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
     sendVoxelUpdate: Scalars['Boolean']['output'];
     /** Creates or updates an app's monthly spend cap (idempotent upsert keyed by org + app) and returns the resulting budget. This only records the cap used to monitor/limit overspend; it does not move money, charge a card, or alter the wallet balance. Requires the 'manage_billing' app permission. */
     setAppBudget: AppBudget;
+    /** Register/update an app's portal client settings (redirect_uris, client_type, launch_url). Requires manage_apps on the app and a SESSION token. */
+    setAppClientSettings: PortalConsentState;
+    /** Reserve sustained egress throughput for a shared app (bypasses the ~1 MB/s free-tier rate limit). Billed at $3/MB/s/month from the org wallet; upgrades are prorated for the current month. Requires 'manage_billing' on the app's org. */
+    setAppReservedThroughput: SetAppReservedThroughputResult;
     /** Sets per-app hourly/daily spend caps (in cents) and returns the re-evaluated runtime state. Pass null for a limit to clear that cap. Exceeding a cap denies the app's runtime (runtimeDenialReason = spend_cap). Requires the 'manage_billing' permission on the app's org. */
     setAppSpendCaps: AppRuntimeState;
     /** Super admin only (also requires the management API to be enabled for this deployment). Overrides an app visibility platform-wide, e.g. to take down (PRIVATE/UNLISTED) or relist (PUBLIC) an app. Throws ForbiddenException for non-super-admins or when management APIs are disabled. Throws if the app id does not exist. */
@@ -3157,8 +3285,14 @@ export type Mutation = {
     setTeamPolicy: AppGroupPolicy;
     /** Begins vaulting a card for off-session auto-billing. Returns a Stripe SetupIntent client secret the browser confirms; no charge is made here. Requires the 'manage_billing' org permission. */
     setupSharedPaymentMethod: PaymentMethodSetup;
+    /** Complete a federated sign-in from the provider callback (code + state). Returns a session AuthResponse, creating/linking the account by provider identity. Public. */
+    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. */
+    socialLoginStart: SocialLoginStart;
     /** 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;
+    /** Unlink a federated identity from the signed-in account by identityId. Refuses to remove your last remaining sign-in method. Requires a session token. */
+    unlinkIdentity: Scalars['Boolean']['output'];
     /** Update an existing access tier (name, ordering, pricing, permissions, etc.); only fields present in the input are changed. Requires the 'manage_access_tiers' permission on the app that owns the tier (resolved from tierId); super admins bypass. SIDE EFFECTS: re-syncs the tier's permissions to the game API. Throws if the tier is not found or the caller lacks permission. */
     updateAccessTier: AppAccessTier;
     /** Partially updates an actor (appId, avatarId, chunk, publicState, privateState); fields omitted from `input` are left unchanged. OWNER-EXCLUSIVE: only the actor’s owner may update (throws Unauthorized otherwise). Requires a valid game token. `uuid` is the 32-character ASCII actor id. */
@@ -3232,6 +3366,9 @@ export type MutationArchiveAppArgs = {
 export type MutationAssignGroupToGridArgs = {
     input: AssignGroupToGridInput;
 };
+export type MutationAuthorizeAppArgs = {
+    input: AuthorizeAppInput;
+};
 export type MutationCancelSharedSubscriptionArgs = {
     appId: Scalars['BigInt']['input'];
     idempotencyKey?: InputMaybe<Scalars['String']['input']>;
@@ -3247,6 +3384,9 @@ export type MutationChangePasswordArgs = {
 export type MutationClaimFreeAppAccessArgs = {
     appId: Scalars['BigInt']['input'];
 };
+export type MutationCompleteLoginLinkArgs = {
+    input: CompleteLoginLinkInput;
+};
 export type MutationConfirmEmailArgs = {
     token: Scalars['String']['input'];
 };
@@ -3337,6 +3477,9 @@ export type MutationDeleteUserAppStateArgs = {
 export type MutationDestroyEnvironmentArgs = {
     input: DestroyEnvironmentInput;
 };
+export type MutationDevLoginArgs = {
+    input: DevLoginInput;
+};
 export type MutationExchangePortalCodeArgs = {
     input: ExchangePortalCodeInput;
 };
@@ -3363,10 +3506,27 @@ export type MutationGameModelDeleteAutomationTriggerArgs = {
     appId: Scalars['BigInt']['input'];
     triggerId: Scalars['String']['input'];
 };
+export type MutationGameModelDeleteContainerArgs = {
+    appId: Scalars['BigInt']['input'];
+    containerId: Scalars['String']['input'];
+};
+export type MutationGameModelDeleteContainerTypeArgs = {
+    appId: Scalars['BigInt']['input'];
+    typeName: Scalars['String']['input'];
+};
+export type MutationGameModelDeleteEdgeArgs = {
+    appId: Scalars['BigInt']['input'];
+    edgeId: Scalars['String']['input'];
+};
 export type MutationGameModelDeleteFunctionArgs = {
     appId: Scalars['BigInt']['input'];
     name: Scalars['String']['input'];
 };
+export type MutationGameModelDeletePropertyDefArgs = {
+    appId: Scalars['BigInt']['input'];
+    containerTypeName: Scalars['String']['input'];
+    key: Scalars['String']['input'];
+};
 export type MutationGameModelGrantTierFeatureArgs = {
     input: GrantTierFeatureInput;
 };
@@ -3449,6 +3609,9 @@ export type MutationLeaveTeamArgs = {
 export type MutationLinkAppToEnvironmentArgs = {
     input: LinkAppToEnvironmentInput;
 };
+export type MutationLinkIdentityArgs = {
+    input: LinkIdentityInput;
+};
 export type MutationLoginArgs = {
     loginUserInput: LoginUserInput;
 };
@@ -3505,6 +3668,9 @@ export type MutationRemoveTeamMemberArgs = {
     groupId: Scalars['BigInt']['input'];
     userId: Scalars['BigInt']['input'];
 };
+export type MutationRequestLoginLinkArgs = {
+    input: RequestLoginLinkInput;
+};
 export type MutationRequestPasswordResetArgs = {
     email: Scalars['String']['input'];
 };
@@ -3531,6 +3697,9 @@ export type MutationRevokeAppAccessArgs = {
     idempotencyKey?: InputMaybe<Scalars['String']['input']>;
     userId: Scalars['BigInt']['input'];
 };
+export type MutationRevokeAppAuthorizationArgs = {
+    appId: Scalars['BigInt']['input'];
+};
 export type MutationRevokeGridPermissionsArgs = {
     input: RevokeGridPermissionsInput;
 };
@@ -3571,6 +3740,13 @@ export type MutationSetAppBudgetArgs = {
     monthlyLimitCents: Scalars['BigInt']['input'];
     orgId: Scalars['BigInt']['input'];
 };
+export type MutationSetAppClientSettingsArgs = {
+    input: SetAppClientSettingsInput;
+};
+export type MutationSetAppReservedThroughputArgs = {
+    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
+    input: SetAppReservedThroughputInput;
+};
 export type MutationSetAppSpendCapsArgs = {
     appId: Scalars['BigInt']['input'];
     dailyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
@@ -3630,9 +3806,18 @@ export type MutationSetupSharedPaymentMethodArgs = {
     idempotencyKey?: InputMaybe<Scalars['String']['input']>;
     orgId: Scalars['BigInt']['input'];
 };
+export type MutationSocialLoginCompleteArgs = {
+    input: SocialLoginCompleteInput;
+};
+export type MutationSocialLoginStartArgs = {
+    input: SocialLoginStartInput;
+};
 export type MutationTeleportRequestArgs = {
     input: TeleportRequestInput;
 };
+export type MutationUnlinkIdentityArgs = {
+    identityId: Scalars['String']['input'];
+};
 export type MutationUpdateAccessTierArgs = {
     input: UpdateAccessTierInput;
     tierId: Scalars['BigInt']['input'];
@@ -3753,6 +3938,20 @@ export type NotificationArgInput = {
     /** Argument name (kind-specific: chunk_x, channel_id, payload, target_uuid, ...). */
     name: Scalars['String']['input'];
 };
+/** Per-app projection row within an org rollup. */
+export type OrgAppUsageProjectionRow = {
+    __typename?: 'OrgAppUsageProjectionRow';
+    /** App id (as a string). */
+    appId: Scalars['String']['output'];
+    /** App display name. */
+    appName: Scalars['String']['output'];
+    /** Egress bytes so far this calendar month. */
+    currentEgressBytes: Scalars['String']['output'];
+    /** True when this app is on track to exceed its free allowance, or null when insufficient data. */
+    onTrackToExceed: Maybe<Scalars['Boolean']['output']>;
+    /** Projected end-of-month egress bytes, or null when insufficient data. */
+    projectedBytes: Maybe<Scalars['String']['output']>;
+};
 /** Org off-session auto-billing configuration. */
 export type OrgAutoBilling = {
     __typename?: 'OrgAutoBilling';
@@ -3871,6 +4070,40 @@ export type OrgTokenWithSecret = {
     /** The plaintext token. Save it now; it is not stored. */
     token: Scalars['String']['output'];
 };
+/** Org-level rollup of per-app monthly egress projections for all shared apps. */
+export type OrgUsageProjection = {
+    __typename?: 'OrgUsageProjection';
+    /** Per-app projection breakdown. */
+    apps: Array<OrgAppUsageProjectionRow>;
+    /** Fractional UTC days elapsed since the calendar month started. */
+    daysElapsed: Scalars['Float']['output'];
+    /** True when any shared app is on track to exceed its free allowance. */
+    onTrackToExceedAny: Scalars['Boolean']['output'];
+    /** True when at least 3 days have elapsed in the month (projection is meaningful). */
+    sufficientData: Scalars['Boolean']['output'];
+    /** True when org total projected egress exceeds the combined free tier — suggest reserved throughput. */
+    suggestReservedThroughput: Scalars['Boolean']['output'];
+    /** Total free monthly egress allowance across all shared apps in the org (apps × 5 GB). */
+    totalFreeAllowanceBytes: Scalars['String']['output'];
+    /** Sum of projected end-of-month egress across shared apps, or null when insufficient data. */
+    totalProjectedBytes: Maybe<Scalars['String']['output']>;
+};
+/** Org-level rollup of replication/GraphQL byte totals and GraphQL op counts across all apps in the organization for the time window. */
+export type OrgUsageSummary = {
+    __typename?: 'OrgUsageSummary';
+    /** Total GraphQL bytes received across all org apps (string counter). */
+    graphqlRecvBytes: Scalars['String']['output'];
+    /** Total GraphQL bytes sent across all org apps (string counter). */
+    graphqlSendBytes: Scalars['String']['output'];
+    /** Organization id (as a string). */
+    orgId: Scalars['String']['output'];
+    /** Total replication bytes received across all org apps (string counter). */
+    replicationRecvBytes: Scalars['String']['output'];
+    /** Total replication bytes sent across all org apps (string counter). */
+    replicationSendBytes: Scalars['String']['output'];
+    /** Total GraphQL operations (send + recv) across all org apps (string counter). */
+    totalOps: Scalars['String']['output'];
+};
 export type OrgWallet = {
     __typename?: 'OrgWallet';
     /** Current wallet balance in minor currency units (cents) of `currency`, as a BigInt decimal string. May be negative if usage was charged against an empty wallet. */
@@ -4012,6 +4245,20 @@ export type PortalAuthorizationCode = {
     /** The validated redirect URI the player should be sent to. */
     redirectUri: Scalars['String']['output'];
 };
+/** Whether portaling into an app requires a consent prompt on the Overworld. */
+export type PortalConsentState = {
+    __typename?: 'PortalConsentState';
+    /** True if the user already has an active grant for this app. */
+    alreadyGranted: Scalars['Boolean']['output'];
+    /** App id, as a String. */
+    appId: Scalars['String']['output'];
+    /** App display name. */
+    appName: Maybe<Scalars['String']['output']>;
+    /** True if the Overworld must show a consent screen (untrusted app, not yet granted) before creating a portal code. */
+    consentRequired: Scalars['Boolean']['output'];
+    /** True for first-party/trusted apps (consent is always skipped). */
+    trusted: Scalars['Boolean']['output'];
+};
 /** Postgres billing tier: bandwidth allotment and capacity charge. Usage metering deferred. */
 export type PostgresBillingTier = {
     __typename?: 'PostgresBillingTier';
@@ -4060,6 +4307,8 @@ export type Query = {
     actors: Array<Actor>;
     /** Relay-style cursor-paginated version of `actors`: lists actors owned by the authenticated user, optionally narrowed by `filter` (appId, avatarId, uuid, chunk). Page forward with `first` (default 50, max 200) and `after` (an opaque cursor from a previous page’s `pageInfo.endCursor`); `totalCount` is the full number of matching actors. Requires a valid game token; only the caller’s own actors are returned (full state included). */
     actorsConnection: ActorsConnection;
+    /** 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. */
     app: Maybe<App>;
     /** Public listing of an app's access tiers (the free/paid bundles of runtime permissions), ordered by tierOrder ascending. PUBLIC: no authentication required. Powers the marketplace app detail / pricing page. Includes tiers of all statuses; inspect AppAccessTier.status to skip archived tiers. */
@@ -4078,6 +4327,8 @@ export type Query = {
     appRuntimeState: AppRuntimeState;
     /** An app's paid shared-environment subscription, or null when it has none (e.g. unpublished or on the free quota). Caller must be a member of the app's org. */
     appSharedSubscription: Maybe<AppSharedSubscription>;
+    /** Linear end-of-month egress projection for one shared app from calendar-month usage so far. Requires at least 3 elapsed days in the month before returning projected values. Requires the 'view_usage' org permission. */
+    appUsageProjection: AppUsageProjection;
     /** Replication and GraphQL byte totals plus the top GraphQL operations for one app over the time range. Read-only reporting; the app must be linked to an environment in the org. Requires the 'view_usage' org permission. */
     appUsageSummary: AppUsageSummary;
     /** Admin view of the user access records for an app (who has been granted/revoked access and on which tier). Requires the 'manage_access_tiers' permission on the app; super admins bypass. Ordered by most recently updated. Paginated via limit/offset. */
@@ -4090,6 +4341,8 @@ export type Query = {
     appsConnection: AppsConnection;
     /** All apps belonging to an organization, identified by the org's slug, regardless of visibility or status (includes drafts and archived). Requires authentication; intended for org dashboards. Ordered newest-first. Returns an empty list for an unknown slug. */
     appsForOrg: Array<App>;
+    /** The federated sign-in providers currently enabled (e.g. ['google']). Use one with socialLoginStart. The dev mock provider only appears when the dev bypass is enabled. */
+    availableLoginProviders: Array<Scalars['String']['output']>;
     /** Fetches a single avatar by id. Requires a valid game token. Owner-aware: the owner receives full state; non-owners receive a public copy with `privateState` stripped (null). Throws NotFound if the id does not exist. State blobs are base64-encoded binary. */
     avatar: Avatar;
     /** Reads one avatar’s per-app state (keyed by appId+avatarId). PUBLIC READ: any authenticated user may read it. Requires a valid game token. Returns null when no row exists. `state` is base64-encoded binary. */
@@ -4110,6 +4363,8 @@ export type Query = {
     channelRoles: Array<GroupRole>;
     /** List all active channels in an app (not just the caller's). */
     channels: Array<Group>;
+    /** Email-first adaptive login: check whether the account has password sign-in enabled. Public; does not reveal whether the email is registered. */
+    checkAuthMethod: AuthMethodResult;
     /** Cross-tenant payments audit across all users, orgs, and apps (newest first), with optional filtering. Restricted to super admins; requests from non-super-admins are rejected. For a caller's own history use `myCheckouts` instead. */
     checkouts: CheckoutsPage;
     /** Cross-tenant payments audit across all users, orgs, and apps (newest first), with optional filtering. Restricted to super admins; requests from non-super-admins are rejected. For a caller's own history use `myCheckoutsConnection` instead. Relay cursor connection; prefer this over the offset-based checkouts. */
@@ -4234,6 +4489,8 @@ export type Query = {
     myAppAccess: Maybe<AppUserAccess>;
     /** Apps the authenticated caller can see in their account: those owned by an org they are an active member of, OR those where they hold an active app_user_access grant. Requires authentication. Includes apps of any visibility/status (e.g. drafts the caller can access). Ordered newest-first. */
     myApps: Array<App>;
+    /** The calling user's active app authorizations ("connected apps"). Requires a SESSION token. */
+    myAuthorizedApps: Array<AppAuthorizationGrant>;
     /** Lists all avatars owned by the authenticated user, including full `publicState` and `privateState` (the caller is always the owner here). Requires a valid bearer game token; takes no arguments. State blobs are base64-encoded binary. Use `userAvatars` to view another user’s avatars (private state is stripped for non-owners). */
     myAvatars: Array<AvatarDto>;
     /** The caller's channels in an app, with their roles and effective channel permissions (e.g. whether they hold send_messages). Use this to discover which channels the current user can read/post in. */
@@ -4247,6 +4504,8 @@ export type Query = {
      * @deprecated Legacy donation/property-token data; these products are no longer purchasable. Retained for historical records.
      */
     myDonationData: UserDonationData;
+    /** 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. */
     myOrganizations: Array<OrgMembership>;
     /**
@@ -4280,6 +4539,10 @@ export type Query = {
     orgTokens: Array<OrgToken>;
     /** Aggregate replication/GraphQL byte totals per environment across the org for the time window. Read-only reporting. Requires the 'view_usage' org permission. */
     orgUsageByEnvironment: Array<EnvironmentUsageRollupRow>;
+    /** Org rollup of per-app monthly egress projections for all shared apps, with upgrade prompts when on track to exceed free tier. Requires the 'view_usage' org permission. */
+    orgUsageProjection: OrgUsageProjection;
+    /** Org-level rollup of replication/GraphQL byte totals and GraphQL op counts across all apps in the organization for the time window. Read-only reporting. Requires the 'view_usage' org permission. */
+    orgUsageSummary: OrgUsageSummary;
     /** Fetches an organization by id (BigInt as string). Requires a valid session token. Returns null if no such organization exists. */
     organization: Maybe<Organization>;
     /** Fetches an organization by its unique URL slug. Requires a valid session token. Returns null if not found. Use this when you only have the slug; otherwise prefer organization(id). */
@@ -4288,10 +4551,12 @@ export type Query = {
     paymentEvents: PaymentEventsPage;
     /** Audit log of inbound payment-provider webhook events (used for idempotent reconciliation of checkouts), newest first. Restricted to super admins; requests from non-super-admins are rejected. Relay cursor connection; prefer this over the offset-based paymentEvents. */
     paymentEventsConnection: PaymentEventsConnection;
-    /** Public platform discovery. Returns the shared game-api URL clients use for shared-environment apps. No auth required. */
+    /** Public platform discovery. Returns the shared game-api URL clients use for shared-environment apps (served by the platform shared environment). No auth required. */
     platformConfig: PlatformConfig;
     /** Live concurrent players for the org vs its all-time peak, a percentile comparison against other studios, and the site-wide total. Requires the 'view_usage' org permission. */
     playerPulse: PlayerPulse;
+    /** Whether portaling the calling user into an app needs a consent prompt. Trusted (first-party) apps and already-granted apps return consentRequired=false. The Overworld calls this before createPortalAuthorizationCode. Requires a SESSION token. */
+    portalConsent: PortalConsentState;
     /** Public read-only catalog of active Postgres billing tiers. Usage metering deferred. */
     postgresBillingTiers: Array<PostgresBillingTier>;
     /** Lists the app-scoped quota rules explicitly configured for an app (excludes org-, tier-, and free-tier-default quotas). Use `effectiveQuota` to resolve the limit actually applied for a given metric. Requires the 'view_usage' app permission. */
@@ -4352,6 +4617,9 @@ export type QueryActorsConnectionArgs = {
     filter?: InputMaybe<ActorFilterInput>;
     first?: InputMaybe<Scalars['Int']['input']>;
 };
+export type QueryAmIGameHostArgs = {
+    appId: Scalars['BigInt']['input'];
+};
 export type QueryAppArgs = {
     appId: Scalars['BigInt']['input'];
 };
@@ -4384,6 +4652,10 @@ export type QueryAppRuntimeStateArgs = {
 export type QueryAppSharedSubscriptionArgs = {
     appId: Scalars['BigInt']['input'];
 };
+export type QueryAppUsageProjectionArgs = {
+    appId: Scalars['BigInt']['input'];
+    orgId: Scalars['BigInt']['input'];
+};
 export type QueryAppUsageSummaryArgs = {
     appId: Scalars['BigInt']['input'];
     operationLimit?: InputMaybe<Scalars['Int']['input']>;
@@ -4444,6 +4716,9 @@ export type QueryChannelRolesArgs = {
 export type QueryChannelsArgs = {
     appId: Scalars['BigInt']['input'];
 };
+export type QueryCheckAuthMethodArgs = {
+    input: CheckAuthMethodInput;
+};
 export type QueryCheckoutsArgs = {
     filter?: InputMaybe<CheckoutFilterInput>;
     limit?: InputMaybe<Scalars['Int']['input']>;
@@ -4704,6 +4979,13 @@ export type QueryOrgUsageByEnvironmentArgs = {
     orgId: Scalars['BigInt']['input'];
     since: Scalars['DateTime']['input'];
 };
+export type QueryOrgUsageProjectionArgs = {
+    orgId: Scalars['BigInt']['input'];
+};
+export type QueryOrgUsageSummaryArgs = {
+    orgId: Scalars['BigInt']['input'];
+    since?: InputMaybe<Scalars['DateTime']['input']>;
+};
 export type QueryOrganizationArgs = {
     id: Scalars['BigInt']['input'];
 };
@@ -4721,6 +5003,9 @@ export type QueryPaymentEventsConnectionArgs = {
 export type QueryPlayerPulseArgs = {
     orgId: Scalars['BigInt']['input'];
 };
+export type QueryPortalConsentArgs = {
+    appId: Scalars['BigInt']['input'];
+};
 export type QueryQuotasForAppArgs = {
     appId: Scalars['BigInt']['input'];
 };
@@ -4827,6 +5112,21 @@ export type RegisterUserInput = {
     /** Password for the new account (min 8 characters). */
     password: Scalars['String']['input'];
 };
+/** Request an emailed magic-link to sign in (passwordless). */
+export type RequestLoginLinkInput = {
+    /** Email address to send the one-time sign-in link to. */
+    email: Scalars['String']['input'];
+    /** Where to send the user after they click the link (origin must be an allowed app/UI origin). Defaults to the platform sign-in page. */
+    redirectUri?: InputMaybe<Scalars['String']['input']>;
+};
+/** Result of requesting a magic link. */
+export type RequestLoginLinkResult = {
+    __typename?: 'RequestLoginLinkResult';
+    /** DEV ONLY: when DEV_AUTH_BYPASS is enabled (so no email is delivered), the one-time token to pass to completeLoginLink. Always null in production. */
+    devToken: Maybe<Scalars['String']['output']>;
+    /** Always true (does not reveal whether the email exists). */
+    sent: Scalars['Boolean']['output'];
+};
 export type ResetPasswordInput = {
     /** New password to set (min 8 characters). */
     newPassword: Scalars['String']['input'];
@@ -5149,6 +5449,33 @@ export type ServiceQuota = {
     /** When the rule was last updated (ISO-8601 UTC timestamp). */
     updatedAt: Scalars['DateTime']['output'];
 };
+/** Register/update an app's OAuth client settings for the portal handoff (requires manage_apps on the app). */
+export type SetAppClientSettingsInput = {
+    appId: Scalars['BigInt']['input'];
+    /** OAuth client type: 'public' (browser/PKCE) or 'confidential'. */
+    clientType?: InputMaybe<Scalars['String']['input']>;
+    /** Browser launch URL players are sent to when entering the app. */
+    launchUrl?: InputMaybe<Scalars['String']['input']>;
+    /** Allow-listed redirect URIs for the portal authorization code (origin-matched). Replaces the current list. */
+    redirectUris?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+/** Set or change an app's reserved sustained throughput on the shared environment. */
+export type SetAppReservedThroughputInput = {
+    /** App to configure reserved throughput for. */
+    appId: Scalars['BigInt']['input'];
+    /** Organization that owns the app. */
+    orgId: Scalars['BigInt']['input'];
+    /** Reserved sustained egress in bytes/s (decimal MB/s: 1_000_000 = 1 MB/s). 0 clears the reservation (free tier). */
+    reservedBytesPerSec: Scalars['BigInt']['input'];
+};
+/** Result of setAppReservedThroughput: updated app + reservation fee debited (0 when downgrading or unchanged). */
+export type SetAppReservedThroughputResult = {
+    __typename?: 'SetAppReservedThroughputResult';
+    /** App after the reservation change. */
+    app: App;
+    /** Cents debited from the org wallet for this change (prorated upgrade). 0 when clearing or lowering reservation. */
+    chargedCents: Scalars['BigInt']['output'];
+};
 /** Set the per-app automation policy (guardrails / platform ceilings). */
 export type SetAutomationPolicyInput = {
     /** The app (tenant). */
@@ -5311,6 +5638,29 @@ export type SingleActorMessageNotification = {
     /** The destination actor’s UUID (your own actor’s UUID, echoed from the message). */
     uuid: Scalars['String']['output'];
 };
+/** Complete a federated sign-in from the provider callback. */
+export type SocialLoginCompleteInput = {
+    /** The authorization code returned by the provider. */
+    code: Scalars['String']['input'];
+    provider: Scalars['String']['input'];
+    /** The opaque state value from socialLoginStart (CSRF binding). */
+    state: Scalars['String']['input'];
+};
+/** A federated sign-in handoff: redirect the user to authorizeUrl. */
+export type SocialLoginStart = {
+    __typename?: 'SocialLoginStart';
+    /** Provider authorize URL to redirect the user to. */
+    authorizeUrl: Scalars['String']['output'];
+    /** Opaque state to round-trip back to socialLoginComplete. */
+    state: Scalars['String']['output'];
+};
+/** Begin a federated (social) sign-in. */
+export type SocialLoginStartInput = {
+    /** Provider id, e.g. 'google' (see availableLoginProviders). */
+    provider: Scalars['String']['input'];
+    /** The callback URL the provider returns to (must be a registered auth callback for your app/UI). */
+    redirectUri: Scalars['String']['input'];
+};
 export type Subscription = {
     __typename?: 'Subscription';
     /** Realtime downlink from the game server: spatial notifications and responses, GenericErrorResponse (errors from your sends, correlated by sequenceNumber), and RealtimeConnectionEvent (lifecycle/setup failures). Requires a bearer game token AND an appId-scoped connection — the appId is read from the graphql-transport-ws connection (game tokens are app-agnostic and one UDP socket is shared across apps, so an app-agnostic subscription is rejected with a RealtimeConnectionEvent code APP_ID_REQUIRED, and a missing/invalid token with AUTH_REQUIRED). On subscribe, opens a UDP proxy session if none exists (binds to the least-loaded game server); open/transport failures are delivered as RealtimeConnectionEvent (code UDP_PROXY_CONNECTION_FAILED) and then the stream ends. Only this app’s spatial fan-out is delivered; appId-less control frames always pass. Subscribe before/while sending so async results are not missed. Unsubscribing stops delivery only — it does NOT close the UDP session; call disconnectUdpProxy (or rely on the server inactivity timeout) to release it. */
@@ -5829,6 +6179,20 @@ export type UserEdge = {
     /** The node at the end of this edge. */
     node: User;
 };
+/** A federated / passwordless sign-in identity linked to a user account (a social provider, an emailed magic link, or the dev bypass). */
+export type UserIdentity = {
+    __typename?: 'UserIdentity';
+    createdAt: Scalars['DateTime']['output'];
+    email: Maybe<Scalars['String']['output']>;
+    emailVerified: Scalars['Boolean']['output'];
+    identityId: Scalars['ID']['output'];
+    lastLoginAt: Maybe<Scalars['DateTime']['output']>;
+    /** The identity provider: 'google' | 'apple' | 'discord' | 'email' (magic link) | 'dev' (dev bypass). */
+    provider: Scalars['String']['output'];
+    /** The provider's stable subject id ('sub'). For 'email'/'dev' this is the lowercased email. */
+    subject: Scalars['String']['output'];
+    userId: Scalars['ID']['output'];
+};
 /** Aggregated property-token balances for a user. LEGACY: property tokens are no longer purchasable. Returned by the deprecated myPropertyTokens query. */
 export type UserPropertyTokenData = {
     __typename?: 'UserPropertyTokenData';
@@ -6070,7 +6434,7 @@ export type WalletTransaction = {
     referenceId: Maybe<Scalars['String']['output']>;
     /** Unique transaction id (BigInt as a decimal string). */
     transactionId: Scalars['BigInt']['output'];
-    /** What produced this transaction. Known values: "topup" (wallet credit from a checkout/top-up), "usage" (per-app usage charge, negative), "shared_usage" (shared-environment usage charge, negative), "environment_usage" (hourly environment cost, negative), "auto_recharge" (automatic wallet recharge). Other caller-supplied deposit types are possible. */
+    /** What produced this transaction. Known values: "topup" (wallet credit from a checkout/top-up), "usage" (per-app usage charge, negative), "shared_usage" (shared-environment usage charge, negative), "reserved_throughput" (monthly/prorated reserved egress capacity, negative), "environment_usage" (hourly environment cost, negative), "auto_recharge" (automatic wallet recharge). Other caller-supplied deposit types are possible. */
     transactionType: Scalars['String']['output'];
     /** Wallet this transaction belongs to (BigInt as a decimal string). */
     walletId: Scalars['BigInt']['output'];
@@ -6776,47 +7140,6 @@ export type UpdateAppMutation = {
         updatedAt: string;
     };
 };
-export type ChangePasswordMutationVariables = Exact<{
-    currentPassword: Scalars['String']['input'];
-    newPassword: Scalars['String']['input'];
-}>;
-export type ChangePasswordMutation = {
-    __typename?: 'Mutation';
-    changePassword: boolean;
-};
-export type ConfirmEmailMutationVariables = Exact<{
-    token: Scalars['String']['input'];
-}>;
-export type ConfirmEmailMutation = {
-    __typename?: 'Mutation';
-    confirmEmail: boolean;
-};
-export type LoginMutationVariables = Exact<{
-    input: LoginUserInput;
-}>;
-export type LoginMutation = {
-    __typename?: 'Mutation';
-    login: {
-        __typename?: 'AuthResponse';
-        token: string;
-        gameTokenId: string;
-        user: {
-            __typename?: 'User';
-            userId: string;
-            email: string | null;
-            gamertag: string | null;
-            disambiguation: string | null;
-            isConfirmed: boolean;
-            createdAt: string;
-            grantEarlyAccess: boolean;
-            grantEarlyAccessOverride: boolean;
-            orgId: string | null;
-            externalId: string | null;
-            userType: string;
-            isSuperAdmin: boolean;
-        };
-    };
-};
 export type LogoutMutationVariables = Exact<{
     [key: string]: never;
 }>;
@@ -6831,53 +7154,6 @@ export type LogoutAllDevicesMutation = {
     __typename?: 'Mutation';
     logoutAllDevices: boolean;
 };
-export type RegisterMutationVariables = Exact<{
-    input: RegisterUserInput;
-}>;
-export type RegisterMutation = {
-    __typename?: 'Mutation';
-    register: {
-        __typename?: 'AuthResponse';
-        token: string;
-        gameTokenId: string;
-        user: {
-            __typename?: 'User';
-            userId: string;
-            email: string | null;
-            gamertag: string | null;
-            disambiguation: string | null;
-            isConfirmed: boolean;
-            createdAt: string;
-            grantEarlyAccess: boolean;
-            grantEarlyAccessOverride: boolean;
-            orgId: string | null;
-            externalId: string | null;
-            userType: string;
-            isSuperAdmin: boolean;
-        };
-    };
-};
-export type RequestPasswordResetMutationVariables = Exact<{
-    email: Scalars['String']['input'];
-}>;
-export type RequestPasswordResetMutation = {
-    __typename?: 'Mutation';
-    requestPasswordReset: boolean;
-};
-export type ResendConfirmationEmailMutationVariables = Exact<{
-    email: Scalars['String']['input'];
-}>;
-export type ResendConfirmationEmailMutation = {
-    __typename?: 'Mutation';
-    resendConfirmationEmail: boolean;
-};
-export type ResetPasswordMutationVariables = Exact<{
-    input: ResetPasswordInput;
-}>;
-export type ResetPasswordMutation = {
-    __typename?: 'Mutation';
-    resetPassword: boolean;
-};
 export type UserAvatarsQueryVariables = Exact<{
     userId: Scalars['BigInt']['input'];
 }>;
@@ -9160,6 +9436,14 @@ export type GameModelCreateContainerMutation = {
         metadataJson: string;
     };
 };
+export type GameModelDeleteContainerMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    containerId: Scalars['String']['input'];
+}>;
+export type GameModelDeleteContainerMutation = {
+    __typename?: 'Mutation';
+    gameModelDeleteContainer: boolean;
+};
 export type GameModelSetPropertyMutationVariables = Exact<{
     input: SetContainerPropertyInput;
 }>;
@@ -9191,6 +9475,14 @@ export type GameModelAddEdgeMutation = {
         weight: number | null;
     };
 };
+export type GameModelDeleteEdgeMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    edgeId: Scalars['String']['input'];
+}>;
+export type GameModelDeleteEdgeMutation = {
+    __typename?: 'Mutation';
+    gameModelDeleteEdge: boolean;
+};
 export type GameModelInvokeMutationVariables = Exact<{
     input: InvokeFunctionInput;
 }>;
@@ -9503,6 +9795,23 @@ export type GameModelUpsertPropertyDefMutation = {
         description: string | null;
     };
 };
+export type GameModelDeletePropertyDefMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    containerTypeName: Scalars['String']['input'];
+    key: Scalars['String']['input'];
+}>;
+export type GameModelDeletePropertyDefMutation = {
+    __typename?: 'Mutation';
+    gameModelDeletePropertyDef: boolean;
+};
+export type GameModelDeleteContainerTypeMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    typeName: Scalars['String']['input'];
+}>;
+export type GameModelDeleteContainerTypeMutation = {
+    __typename?: 'Mutation';
+    gameModelDeleteContainerType: boolean;
+};
 export type GameModelUpsertFunctionMutationVariables = Exact<{
     input: UpsertFunctionInput;
 }>;
@@ -9835,6 +10144,13 @@ export type GameHostQuery = {
         earliestActorJoinedAt: string;
     } | null;
 };
+export type AmIGameHostQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type AmIGameHostQuery = {
+    __typename?: 'Query';
+    amIGameHost: boolean;
+};
 export type ActorHeartbeatMutationVariables = Exact<{
     appId: Scalars['BigInt']['input'];
 }>;
@@ -12015,15 +12331,8 @@ export declare const AppsConnectionDocument: DocumentNode<AppsConnectionQuery, A
 export declare const MyAppsDocument: DocumentNode<MyAppsQuery, MyAppsQueryVariables>;
 export declare const SetAppVisibilityDocument: DocumentNode<SetAppVisibilityMutation, SetAppVisibilityMutationVariables>;
 export declare const UpdateAppDocument: DocumentNode<UpdateAppMutation, UpdateAppMutationVariables>;
-export declare const ChangePasswordDocument: DocumentNode<ChangePasswordMutation, ChangePasswordMutationVariables>;
-export declare const ConfirmEmailDocument: DocumentNode<ConfirmEmailMutation, ConfirmEmailMutationVariables>;
-export declare const LoginDocument: DocumentNode<LoginMutation, LoginMutationVariables>;
 export declare const LogoutDocument: DocumentNode<LogoutMutation, LogoutMutationVariables>;
 export declare const LogoutAllDevicesDocument: DocumentNode<LogoutAllDevicesMutation, LogoutAllDevicesMutationVariables>;
-export declare const RegisterDocument: DocumentNode<RegisterMutation, RegisterMutationVariables>;
-export declare const RequestPasswordResetDocument: DocumentNode<RequestPasswordResetMutation, RequestPasswordResetMutationVariables>;
-export declare const ResendConfirmationEmailDocument: DocumentNode<ResendConfirmationEmailMutation, ResendConfirmationEmailMutationVariables>;
-export declare const ResetPasswordDocument: DocumentNode<ResetPasswordMutation, ResetPasswordMutationVariables>;
 export declare const UserAvatarsDocument: DocumentNode<UserAvatarsQuery, UserAvatarsQueryVariables>;
 export declare const AvatarByIdDocument: DocumentNode<AvatarByIdQuery, AvatarByIdQueryVariables>;
 export declare const MyAvatarsDocument: DocumentNode<MyAvatarsQuery, MyAvatarsQueryVariables>;
@@ -12133,8 +12442,10 @@ export declare const GameModelCreateSessionDocument: DocumentNode<GameModelCreat
 export declare const GameModelJoinSessionDocument: DocumentNode<GameModelJoinSessionMutation, GameModelJoinSessionMutationVariables>;
 export declare const GameModelSetSessionTurnDocument: DocumentNode<GameModelSetSessionTurnMutation, GameModelSetSessionTurnMutationVariables>;
 export declare const GameModelCreateContainerDocument: DocumentNode<GameModelCreateContainerMutation, GameModelCreateContainerMutationVariables>;
+export declare const GameModelDeleteContainerDocument: DocumentNode<GameModelDeleteContainerMutation, GameModelDeleteContainerMutationVariables>;
 export declare const GameModelSetPropertyDocument: DocumentNode<GameModelSetPropertyMutation, GameModelSetPropertyMutationVariables>;
 export declare const GameModelAddEdgeDocument: DocumentNode<GameModelAddEdgeMutation, GameModelAddEdgeMutationVariables>;
+export declare const GameModelDeleteEdgeDocument: DocumentNode<GameModelDeleteEdgeMutation, GameModelDeleteEdgeMutationVariables>;
 export declare const GameModelInvokeDocument: DocumentNode<GameModelInvokeMutation, GameModelInvokeMutationVariables>;
 export declare const GameModelContainerDocument: DocumentNode<GameModelContainerQuery, GameModelContainerQueryVariables>;
 export declare const GameModelContainersDocument: DocumentNode<GameModelContainersQuery, GameModelContainersQueryVariables>;
@@ -12147,6 +12458,8 @@ export declare const GameModelEventsConnectionDocument: DocumentNode<GameModelEv
 export declare const GameModelSeedDocument: DocumentNode<GameModelSeedMutation, GameModelSeedMutationVariables>;
 export declare const GameModelUpsertContainerTypeDocument: DocumentNode<GameModelUpsertContainerTypeMutation, GameModelUpsertContainerTypeMutationVariables>;
 export declare const GameModelUpsertPropertyDefDocument: DocumentNode<GameModelUpsertPropertyDefMutation, GameModelUpsertPropertyDefMutationVariables>;
+export declare const GameModelDeletePropertyDefDocument: DocumentNode<GameModelDeletePropertyDefMutation, GameModelDeletePropertyDefMutationVariables>;
+export declare const GameModelDeleteContainerTypeDocument: DocumentNode<GameModelDeleteContainerTypeMutation, GameModelDeleteContainerTypeMutationVariables>;
 export declare const GameModelUpsertFunctionDocument: DocumentNode<GameModelUpsertFunctionMutation, GameModelUpsertFunctionMutationVariables>;
 export declare const GameModelDeleteFunctionDocument: DocumentNode<GameModelDeleteFunctionMutation, GameModelDeleteFunctionMutationVariables>;
 export declare const GameModelDefineFeatureDocument: DocumentNode<GameModelDefineFeatureMutation, GameModelDefineFeatureMutationVariables>;
@@ -12162,6 +12475,7 @@ export declare const GameModelTierFeaturesDocument: DocumentNode<GameModelTierFe
 export declare const GameModelPolicyDocument: DocumentNode<GameModelPolicyQuery, GameModelPolicyQueryVariables>;
 export declare const GameModelRevokeTierFeatureDocument: DocumentNode<GameModelRevokeTierFeatureMutation, GameModelRevokeTierFeatureMutationVariables>;
 export declare const GameHostDocument: DocumentNode<GameHostQuery, GameHostQueryVariables>;
+export declare const AmIGameHostDocument: DocumentNode<AmIGameHostQuery, AmIGameHostQueryVariables>;
 export declare const ActorHeartbeatDocument: DocumentNode<ActorHeartbeatMutation, ActorHeartbeatMutationVariables>;
 export declare const CreateOrgRoleDocument: DocumentNode<CreateOrgRoleMutation, CreateOrgRoleMutationVariables>;
 export declare const CreateOrgTokenDocument: DocumentNode<CreateOrgTokenMutation, CreateOrgTokenMutationVariables>;