@crowdedkingdoms/crowdyjs 17.14.0-dev.1 → 18.0.0-dev.1

package/dist/domains/gameModel.d.ts

@@ -1,1174 +0,0 @@
-import type { GraphQLClient } from '../client.js';
-import { type GameModelCreateSessionMutation, type GameModelCreateSessionMutationVariables, type GameModelJoinSessionMutation, type GameModelJoinSessionMutationVariables, type GameModelSetSessionTurnMutation, type GameModelSetSessionTurnMutationVariables, type GameModelLeaveSessionMutation, type GameModelLeaveSessionMutationVariables, type GameModelSetSessionAdmissionMutation, type GameModelSetSessionAdmissionMutationVariables, type GameModelTransferSessionHostMutation, type GameModelTransferSessionHostMutationVariables, type GameModelEndSessionMutation, type GameModelEndSessionMutationVariables, type GameModelSessionSnapshotQuery, type GameModelSessionSnapshotQueryVariables, type GameModelSessionEventsQuery, type GameModelSessionEventsQueryVariables, type GameModelSessionInspectQuery, type GameModelSessionInspectQueryVariables, type GameModelSessionChangedSubscription, type GameModelSessionChangedSubscriptionVariables, type GameModelCreateContainerMutation, type GameModelCreateContainerMutationVariables, type GameModelDeleteContainerMutation, type GameModelDeleteContainerMutationVariables, type GameModelSetPropertyMutation, type GameModelSetPropertyMutationVariables, type GameModelAddEdgeMutation, type GameModelAddEdgeMutationVariables, type GameModelDeleteEdgeMutation, type GameModelDeleteEdgeMutationVariables, type GameModelInvokeMutation, type GameModelInvokeMutationVariables, type GameModelContainerQuery, type GameModelContainerQueryVariables, GameModelContainerChangedSubscription, GameModelContainerChangedSubscriptionVariables, type GameModelActivePlayerCountQuery, type GameModelActivePlayerCountQueryVariables, type GameModelActivePlayerCountChangedSubscription, type GameModelActivePlayerCountChangedSubscriptionVariables, type GameModelContainersQuery, type GameModelContainersQueryVariables, type GameModelContainerStateQuery, type GameModelContainerStateQueryVariables, type GameModelContainerStatesQuery, type GameModelContainerStatesQueryVariables, type GameModelTraverseQuery, type GameModelTraverseQueryVariables, type GameModelSessionQuery, type GameModelSessionQueryVariables, type GameModelSessionsQuery, type GameModelSessionsQueryVariables, type GameModelEventsQuery, type GameModelEventsQueryVariables, type GameModelFlowQuery, type GameModelFlowQueryVariables, type GameModelSeedMutation, type GameModelSeedMutationVariables, type GameModelUpsertContainerTypeMutation, type GameModelUpsertContainerTypeMutationVariables, type GameModelUpsertPropertyDefMutation, type GameModelUpsertPropertyDefMutationVariables, type GameModelDeletePropertyDefMutation, type GameModelDeletePropertyDefMutationVariables, type GameModelDeleteContainerTypeMutation, type GameModelDeleteContainerTypeMutationVariables, type GameModelUpsertFunctionMutation, type GameModelUpsertFunctionMutationVariables, type GameModelDeleteFunctionMutation, type GameModelDeleteFunctionMutationVariables, type GameModelDefineFeatureMutation, type GameModelDefineFeatureMutationVariables, type GameModelGrantTierFeatureMutation, type GameModelGrantTierFeatureMutationVariables, type GameModelSetPolicyMutation, type GameModelSetPolicyMutationVariables, type GameModelTypeSchemaQuery, type GameModelTypeSchemaQueryVariables, type GameModelContainerTypesQuery, type GameModelContainerTypesQueryVariables, type GameModelPropertyDefsQuery, type GameModelPropertyDefsQueryVariables, type GameModelFunctionQuery, type GameModelFunctionQueryVariables, type GameModelFunctionsQuery, type GameModelFunctionsQueryVariables, type GameModelFeaturesQuery, type GameModelFeaturesQueryVariables, type GameModelTierFeaturesQuery, type GameModelTierFeaturesQueryVariables, type GameModelPolicyQuery, type GameModelPolicyQueryVariables, type GameModelRevokeTierFeatureMutation, type GameModelRevokeTierFeatureMutationVariables, type GameModelEventsConnectionQuery, type GameModelEventsConnectionQueryVariables, type GameModelUpsertAutomationMutation, type GameModelUpsertAutomationMutationVariables, type GameModelDeleteAutomationMutation, type GameModelDeleteAutomationMutationVariables, type GameModelSetAutomationEnabledMutation, type GameModelSetAutomationEnabledMutationVariables, type GameModelUpsertAutomationTriggerMutation, type GameModelUpsertAutomationTriggerMutationVariables, type GameModelDeleteAutomationTriggerMutation, type GameModelDeleteAutomationTriggerMutationVariables, type GameModelSetAutomationPolicyMutation, type GameModelSetAutomationPolicyMutationVariables, type GameModelRunAutomationMutation, type GameModelRunAutomationMutationVariables, type GameModelAutomationsQuery, type GameModelAutomationsQueryVariables, type GameModelAutomationQuery, type GameModelAutomationQueryVariables, type GameModelAutomationTriggersQuery, type GameModelAutomationTriggersQueryVariables, type GameModelAutomationPolicyQuery, type GameModelAutomationPolicyQueryVariables, type GameModelAutomationRunsQuery, type GameModelAutomationRunsQueryVariables, type GameModelAutomationStatsQuery, type GameModelAutomationStatsQueryVariables, type GameModelAppDiagnosticsQuery, type GameModelAppDiagnosticsQueryVariables, type GameModelScheduleInvokeMutation, type GameModelScheduleInvokeMutationVariables, type GameModelCancelTimerMutation, type GameModelCancelTimerMutationVariables, type GameModelTimersQuery, type GameModelTimersQueryVariables } from '../generated/graphql.js';
-/**
- * Abstract **game-model** sub-client on the **game-api** — a schema-driven,
- * server-authoritative layer for modelling game/world logic on top of the
- * spatial voxel world. Studios *author* the model; players *query* state and
- * *invoke* functions at runtime. Exposed as `client.gameModel`.
- *
- * The model is a typed graph of entities:
- * - **Container types** are the schemas (like classes) for a kind of entity.
- *   **Property definitions** are their typed fields, each with a default value,
- *   a read **visibility** (`public | owner | hidden`) and a **writability**
- *   (`function | owner | admin`). See {@link upsertContainerType} /
- *   {@link upsertPropertyDef} / {@link typeSchema}.
- * - **Containers** are the runtime instances of a type, optionally scoped to a
- *   session and carrying property values. See {@link createContainer},
- *   {@link container}, {@link containers}, {@link containerState}.
- * - **Functions** are named, sandboxed behaviours over containers: typed
- *   parameters, declared property **mutations** (expressions compiled to an AST
- *   server-side — never `eval`'d), an optional return expression, an
- *   `invokeScope` (`player | server | internal`), and an **invoke policy** — an
- *   authority rule tree of `owner_of_self`, `is_host`, `is_current_turn`,
- *   `is_participant`, `tier_feature`, `group_permission`, `grid_permission`, and
- *   `condition` rules. {@link invoke} is the primary, *safe* way for players to
- *   mutate state: the server checks the policy, evaluates the expressions,
- *   applies the mutations atomically, and logs an **event**.
- * - **Sessions** are isolated instance scopes (a match, room, or save) with
- *   **participants**, a creator, and an optional current-**turn** user for
- *   turn-based play. See {@link createSession}, {@link joinSession},
- *   {@link setSessionTurn}, {@link session}, {@link sessions}.
- * - **Edges** are directed, typed relationships between containers (the model is
- *   a graph); {@link traverse} walks them from a root up to a depth. See
- *   {@link addEdge}.
- * - **Events** are an audit log of every function invocation and its outcome.
- *   See {@link events}.
- * - **App features** are keys functions gate on (via `tier_feature` rules) and
- *   that **access tiers** can be granted ({@link defineFeature},
- *   {@link grantTierFeature}); **policy** governs who may create sessions and the
- *   default participant role ({@link setPolicy}).
- * - {@link seed} bulk-creates definitions *and* instances in one transaction for
- *   model init/import.
- *
- * **Encoding.** `BigInt` ids (`appId`, `tierId`, every `*UserId`) are sent and
- * received as decimal **strings**. Container, session, function, edge, and event
- * ids are opaque **UUID strings**. All structured values travel as JSON-encoded
- * strings in the `*Json` fields (`metadataJson`, `propertiesJson`, `paramsJson`,
- * `valueJson`, `returnValueJson`, `invokePolicyJson`, `idMapJson`, …) — callers
- * `JSON.parse` / `JSON.stringify` around them. (Unlike actor/state blobs, these
- * are JSON text, not base64.)
- *
- * **Auth.** Every call requires an authenticated session (a Bearer token set via
- * `client.auth.login()` or `client.setToken()`) scoped to the target app, or it
- * throws {@link CrowdyGraphQLError} (`UNAUTHENTICATED` / `SCOPE_MISSING`). The
- * **studio-authoring** methods ({@link seed}, {@link upsertContainerType},
- * {@link upsertPropertyDef}, {@link deletePropertyDef}, {@link upsertFunction},
- * {@link deleteFunction}, {@link deleteContainerType}, {@link defineFeature},
- * {@link grantTierFeature}, {@link setPolicy}) and the
- * {@link typeSchema} query additionally require the app-admin **`manage_apps`**
- * permission (otherwise `FORBIDDEN`, with `extensions.requiredPermission ===
- * 'manage_apps'`); the runtime/player methods need only a valid token plus
- * whatever per-operation policy applies (session-creation policy, a type's
- * `instantiableBy` rule, a property's `writable` rule, or a function's invoke
- * policy).
- *
- * @example
- * ```ts
- * // Studio authors a type, then a player creates a session and invokes a function.
- * await client.gameModel.upsertContainerType({ appId, typeName: 'Player', displayName: 'Player' });
- * const session = await client.gameModel.createSession({ appId, name: 'Match 1' });
- * const result = await client.gameModel.invoke({
- *   appId,
- *   functionName: 'takeDamage',
- *   selfContainerId,
- *   paramsJson: JSON.stringify({ amount: 10 }),
- * });
- * // Authority and evaluation failures do NOT throw — they come back in band, because
- * // the result still carries an event id and any writes that did apply.
- * const fault = playerFaultOf(result);
- * if (fault) {
- *   // `fault.blame` is the platform's attribution: AUTHOR (this app's code), PLATFORM
- *   // (ours) or BUDGET (an allowance). Choose your own wording — the server no longer
- *   // sends engine text, deliberately.
- *   if (fault.retryable) scheduleRetry();
- * }
- * ```
- */
-/** One container-change push from {@link GameModelAPI.containerChanged}. */
-export type GmContainerChangeEvent = GameModelContainerChangedSubscription['gameModelContainerChanged'];
-/** One session revision as streamed by {@link GameModelAPI.sessionChanged}. */
-export type GmSessionChangeEvent = GameModelSessionChangedSubscription['gameModelSessionChanged'];
-/** Handlers for {@link GameModelAPI.sessionChanged}. */
-export interface SessionChangedHandlers {
-    /**
-     * One revision of the session. `revision` is a decimal string and strictly
-     * increasing; `kind` is one of `created | participant_joined |
-     * participant_rejoined | participant_left | participant_expired |
-     * host_changed | admission_changed | turn_changed | ended`; `payloadJson`
-     * names the subject (user id, host, admission, ...).
-     */
-    next: (event: GmSessionChangeEvent) => void;
-    /** Transport/GraphQL errors (the subscription retries on socket drops). */
-    error?: (error: unknown) => void;
-    /** The server ended the stream. */
-    complete?: () => void;
-    /**
-     * WebSocket constructor for runtimes without a global `WebSocket` (Node
-     * ≤ 21): pass `(await import('ws')).default`.
-     */
-    webSocketImpl?: unknown;
-}
-/** Handlers for {@link GameModelAPI.containerChanged}. */
-export interface ContainerChangedHandlers {
-    /** A container changed (metadata only — pull state on receipt). */
-    next: (change: GmContainerChangeEvent) => void;
-    /** Transport/GraphQL errors (the subscription retries on socket drops). */
-    error?: (error: unknown) => void;
-    /** The server ended the stream. */
-    complete?: () => void;
-    /**
-     * WebSocket constructor for runtimes without a global `WebSocket` (Node
-     * ≤ 21): pass `(await import('ws')).default`.
-     */
-    webSocketImpl?: unknown;
-}
-/** A snapshot returned by {@link GameModelAPI.activePlayerCount}. */
-export type GmActivePlayerCountSnapshot = GameModelActivePlayerCountQuery['gameModelActivePlayerCount'];
-/** One count transition from {@link GameModelAPI.activePlayerCountChanged}. */
-export type GmActivePlayerCountChangeEvent = GameModelActivePlayerCountChangedSubscription['gameModelActivePlayerCountChanged'];
-/** Handlers for {@link GameModelAPI.activePlayerCountChanged}. */
-export interface ActivePlayerCountChangedHandlers {
-    /** A complete app-scoped active-session count transition. */
-    next: (change: GmActivePlayerCountChangeEvent) => void;
-    /** Transport/GraphQL errors (the subscription retries on socket drops). */
-    error?: (error: unknown) => void;
-    /** The server ended the stream. */
-    complete?: () => void;
-    /**
-     * WebSocket constructor for runtimes without a global `WebSocket` (Node
-     * ≤ 21): pass `(await import('ws')).default`.
-     */
-    webSocketImpl?: unknown;
-}
-export declare class GameModelAPI {
-    private gql;
-    private readonly ws?;
-    constructor(gql: GraphQLClient, ws?: {
-        wsUrl?: string;
-        getToken: () => string | null;
-    } | undefined);
-    /**
-     * **Player count** — read the best-known number of active gameplay sessions
-     * for one app. Requires a bearer token scoped to exactly `appId`.
-     *
-     * This is a **session count**, not a distinct-user or actor count: one user
-     * with multiple active sessions contributes more than once. A session that
-     * disappears without a clean disconnect can remain counted for approximately
-     * 120 seconds while its inactivity is recognized.
-     *
-     * Treat the result as authoritative only when `status === 'FRESH'`.
-     * `PARTIAL` is an incomplete best-known count and `UNAVAILABLE` means no fresh
-     * observation exists; neither status is an authoritative zero. `appId` and
-     * the monotonic `revision` are generated `BigInt` scalars represented as
-     * decimal strings.
-     *
-     * @param appId - App to count, as a decimal-string `BigInt`; it must match
-     *   the app scope of the bearer token.
-     * @returns The generated snapshot payload: `appId`, `activePlayerCount`,
-     *   `status`, nullable `observedAt`, and `revision`.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING` when the
-     *   token is missing or is not scoped to `appId`.
-     */
-    activePlayerCount(appId: GameModelActivePlayerCountQueryVariables['appId']): Promise<GmActivePlayerCountSnapshot>;
-    /**
-     * **Player-count subscription** — stream complete active-session count
-     * transitions for one app. Requires a bearer token scoped to exactly
-     * `variables.appId` and a game-api `wsUrl` in the client config.
-     *
-     * This stream counts gameplay **sessions**, not distinct users or actors;
-     * abandoned sessions can remain counted for approximately 120 seconds while
-     * inactivity is recognized. It emits no initial/bootstrap event, so establish
-     * the stream and then call {@link activePlayerCount} for the current snapshot.
-     * `PARTIAL` and `UNAVAILABLE` observations neither emit transitions nor
-     * represent an authoritative zero.
-     *
-     * Delivery is best-effort and may miss or repeat events across reconnects.
-     * Deduplicate by the decimal-string `revision`. Requery
-     * {@link activePlayerCount} after every reconnect or whenever revisions have
-     * a gap; the query is the source of truth.
-     *
-     * @param variables - Exact call shape `{ appId }`, where `appId` is the
-     *   decimal-string `BigInt` matching the app-scoped bearer token.
-     * @param handlers - `next` per transition; optional `error`, `complete`, and
-     *   `webSocketImpl` for runtimes without a global `WebSocket`.
-     * @returns An unsubscribe function that disposes this subscription and its
-     *   graphql-transport-ws client.
-     * @throws {Error} Synchronously when the client config has no `wsUrl`.
-     */
-    activePlayerCountChanged(variables: GameModelActivePlayerCountChangedSubscriptionVariables, handlers: ActivePlayerCountChangedHandlers): () => void;
-    /**
-     * **Subscriptions** — stream container-change notifications for an app
-     * (`gameModelContainerChanged`): an invoke mutated a container, a direct
-     * `setProperty` wrote it, or it was created/deleted. Events are
-     * **metadata only** (containerId, typeName, changedKeys — no property
-     * values): pull the visibility-filtered state with {@link containerState}
-     * on receipt. Post-commit and best-effort, exactly like model-driven
-     * notifications — replaces interval polling with pull-on-push. Requires a
-     * game-api with the container-change feed (2026-07+) and a `wsUrl` in the
-     * client config.
-     *
-     * @param variables - `{ appId, typeName?, sessionId? }` delivery filters.
-     * @param handlers - `next` per change; optional `error` / `complete`.
-     * @returns An unsubscribe function (closes this subscription's socket).
-     */
-    containerChanged(variables: GameModelContainerChangedSubscriptionVariables, handlers: ContainerChangedHandlers): () => void;
-    /**
-     * **Subscriptions** — stream the revisions of one session as they commit
-     * (`gameModelSessionChanged`): joins, rejoins, leaves, presence expiries,
-     * host changes, admission changes, turn changes and the end. There is no
-     * bootstrap event: pull {@link sessionSnapshot} first, or pass
-     * `afterRevision` to replay retained events from there. Revisions are
-     * strictly increasing; on a gap or after a reconnect, pull the snapshot
-     * again. Cross-replica and best-effort over a bounded buffer; the events
-     * table ({@link sessionEvents}) is the record. Requires a `wsUrl` in the
-     * client config.
-     *
-     * @param variables - `{ appId, sessionId, afterRevision? }`.
-     * @param handlers - `next` per revision; optional `error` / `complete` /
-     *   `webSocketImpl`.
-     * @returns An unsubscribe function (closes this subscription's socket).
-     * @throws {Error} Synchronously when the client config has no `wsUrl`.
-     */
-    sessionChanged(variables: GameModelSessionChangedSubscriptionVariables, handlers: SessionChangedHandlers): () => void;
-    /**
-     * **Sessions** — create a runtime session: an isolated instance scope for
-     * containers (e.g. a match, room, or save). Subject to the app's
-     * session-creation policy ({@link setPolicy}); the caller becomes the creator
-     * and a participant.
-     *
-     * **Presence mode.** `presence: 'actor'` (the default) expires a joined
-     * participant with no fresh Buddy actor in the app after the join grace
-     * window. `presence: 'none'` never expires anybody: use it for turn-based
-     * play that talks GraphQL and channel pings and never replicates an actor
-     * (`kit.matches` does), where the roster's only exits are
-     * {@link leaveSession}, {@link endSession} and the empty timeout once
-     * everyone has left. The mode is fixed at creation.
-     *
-     * @param input - {@link CreateSessionInput}: `appId` (decimal string), an
-     *   optional `name`, optional `metadataJson` (a JSON-object string),
-     *   optional `participantUserIds` (decimal-string ids of initial participants
-     *   besides the creator), optional `maxParticipants`, `admission`,
-     *   `emptyTimeoutSec`, `presence` and `idempotencyKey`.
-     *   Pass `seedFromApp: { typeNames, initialState? }` to stamp the app's keyed
-     *   template rows of those types (the rows a {@link seed} with `bindingKey`
-     *   wrote) into the new session inside the creation transaction: same
-     *   `bindingKey`, `displayName`, `metadataJson` and `ownerUserId` per row, so a
-     *   later `gameModelEnsureContainer` in the session finds every key present.
-     *   `initialState` is `'defaults'` (type defaults) or `'app'` (copy the app
-     *   rows' current properties). At most 2,000 rows per session; above that the
-     *   creation is refused and no session exists. The count is on the create
-     *   response as `seededContainerCount` (null on later reads) and on the
-     *   session's `created` event as `containersSeeded`. A template type must be
-     *   `instantiableBy: 'admin'` or carry a `bindPolicyJson` (a plain member
-     *   type is refused: a player may own one of its app keys); an `'app'`-scoped
-     *   type is refused. The copies are marked, and on a tier whose operator has
-     *   enabled retention (`GM_SESSION_CONTAINER_RETENTION_DAYS`; off by default)
-     *   they -- and only they -- are dropped once the session has been ended that
-     *   long; hand-made rows in the session are never purged.
-     * @returns The created {@link GmSession} (`sessionId`, `status`, creator,
-     *   host, admission, `presence`, revision, `seededContainerCount`, …).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING` if the token
-     *   is missing or not scoped to the app, `FORBIDDEN` if the session-creation
-     *   policy disallows the caller, or `BAD_USER_INPUT` for malformed input, an
-     *   undefined `seedFromApp` type, or more than 2,000 template rows.
-     */
-    createSession(input: GameModelCreateSessionMutationVariables['input']): Promise<GameModelCreateSessionMutation['gameModelCreateSession']>;
-    /**
-     * **Sessions** — join a session, or **reconnect** to one you are already in.
-     * A rejoin returns your row with `incarnation + 1` and supersedes any older
-     * client of yours; keep the returned `incarnation`, {@link leaveSession}
-     * needs it. Pass `actorUuid` (your own Buddy actor, 32 hex chars — the uuid
-     * you replicate with) to bind this participant's presence to that actor;
-     * without it any fresh actor of yours in the app keeps you present.
-     * **Presence is your actor** (in a `presence: 'actor'` session, the default):
-     * a participant with no fresh Buddy actor in the app after the join grace
-     * window is expired by the server (`participant_expired`); a client that only
-     * speaks GraphQL must rejoin to come back. In a `presence: 'none'` session
-     * nobody is expired and `actorUuid` is recorded but not judged.
-     *
-     * @param input - {@link JoinSessionInput}: `appId` (decimal string),
-     *   `sessionId`, optional `role`, optional `actorUuid`, optional
-     *   `idempotencyKey` (replaying returns the same incarnation).
-     * @returns The {@link GmSessionParticipant} row (`state`, `incarnation`,
-     *   `actorUuid`, `joinedAt`, ...).
-     * @throws {CrowdyGraphQLError} `SESSION_FULL` (every seat taken),
-     *   `SESSION_LOCKED` (admission locked and you never joined),
-     *   `SESSION_CLOSED`, `SESSION_ENDED`, `FORBIDDEN` (the `actorUuid` is not
-     *   yours or is already bound by another participant), `NOT_FOUND`,
-     *   `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    joinSession(input: GameModelJoinSessionMutationVariables['input']): Promise<GameModelJoinSessionMutation['gameModelJoinSession']>;
-    /**
-     * **Sessions** — set or clear the session's current-turn user, for turn-based
-     * play (turn authority is enforced by the service).
-     *
-     * @param input - {@link SetSessionTurnInput}: `appId` (decimal string),
-     *   `sessionId`, and `userId` (the decimal-string id of the user whose turn it
-     *   now is) — pass `userId: null` to **clear** the turn.
-     * @returns The updated {@link GmSession} (with `currentTurnUserId` reflecting
-     *   the change).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `NOT_FOUND` if the session doesn't exist, or `FORBIDDEN` if the caller may
-     *   not change the turn.
-     */
-    setSessionTurn(input: GameModelSetSessionTurnMutationVariables['input']): Promise<GameModelSetSessionTurnMutation['gameModelSetSessionTurn']>;
-    /**
-     * **Sessions** — leave a session you are joined to. `incarnation` is
-     * **required**: it is the value {@link joinSession} returned to *this*
-     * client (a creator starts at 1), so a superseded client can never remove
-     * the one that took over. Leaving an already-left row is a no-op. If you
-     * were host, the longest-joined present participant succeeds you
-     * (`host_changed`).
-     *
-     * @param input - {@link LeaveSessionInput}: `appId`, `sessionId`,
-     *   `incarnation`, optional `idempotencyKey`.
-     * @returns Your {@link GmSessionParticipant} row, now `state: 'left'` with
-     *   `leftReason: 'left'`.
-     * @throws {CrowdyGraphQLError} `SESSION_INCARNATION_STALE` (a newer client
-     *   rejoined as you — stop acting from this one, or rejoin),
-     *   `SESSION_NOT_PARTICIPANT`, `NOT_FOUND`.
-     */
-    leaveSession(input: GameModelLeaveSessionMutationVariables['input']): Promise<GameModelLeaveSessionMutation['gameModelLeaveSession']>;
-    /**
-     * **Sessions** — change who may still join: `'open'` (anyone the app
-     * admits), `'locked'` (only participants who already joined may reconnect —
-     * set it when the match starts), `'closed'` (nobody). Session host or app
-     * admin (`manage_apps`). Emits `admission_changed`.
-     *
-     * @param input - {@link SetSessionAdmissionInput}: `appId`, `sessionId`,
-     *   `admission`, optional `expectedHostTerm` (the `hostTerm` you last read:
-     *   refused if the host changed since), optional `idempotencyKey`.
-     * @returns The updated {@link GmSession}.
-     * @throws {CrowdyGraphQLError} `FORBIDDEN` (not host / admin),
-     *   `SESSION_HOST_TERM_STALE`, `SESSION_ENDED`, `NOT_FOUND`.
-     */
-    setSessionAdmission(input: GameModelSetSessionAdmissionMutationVariables['input']): Promise<GameModelSetSessionAdmissionMutation['gameModelSetSessionAdmission']>;
-    /**
-     * **Sessions** — hand the host role to another *joined* participant.
-     * Session host or app admin. Increments `hostTerm` and emits
-     * `host_changed` (reason `transferred`).
-     *
-     * @param input - {@link TransferSessionHostInput}: `appId`, `sessionId`,
-     *   `toUserId` (decimal string), optional `expectedHostTerm`, optional
-     *   `idempotencyKey`.
-     * @returns The updated {@link GmSession} (`hostUserId`, `hostTerm`).
-     * @throws {CrowdyGraphQLError} `FORBIDDEN`, `SESSION_HOST_TERM_STALE`,
-     *   `SESSION_TARGET_NOT_PARTICIPANT` (the user named is not joined; refetch
-     *   the snapshot and pick a participant), `SESSION_ENDED`.
-     */
-    transferSessionHost(input: GameModelTransferSessionHostMutationVariables['input']): Promise<GameModelTransferSessionHostMutation['gameModelTransferSessionHost']>;
-    /**
-     * **Sessions** — end a session as `'completed'` (default) or `'abandoned'`.
-     * Every joined participant is marked left (`session_ended`), admission
-     * becomes `closed`, `endedAt` / `endReason` are set and an `ended` event
-     * closes the revision log. Session host or app admin. (The server also ends a
-     * session nobody has been joined to for longer than its `emptyTimeoutSec` as
-     * `abandoned` / `empty_timeout`.)
-     *
-     * @param input - {@link EndSessionInput}: `appId`, `sessionId`, optional
-     *   `reason`, optional `expectedHostTerm`, optional `idempotencyKey`.
-     * @returns The ended {@link GmSession}.
-     * @throws {CrowdyGraphQLError} `FORBIDDEN`, `SESSION_HOST_TERM_STALE`,
-     *   `SESSION_ENDED` (already ended), `NOT_FOUND`.
-     */
-    endSession(input: GameModelEndSessionMutationVariables['input']): Promise<GameModelEndSessionMutation['gameModelEndSession']>;
-    /**
-     * **Containers** — instantiate a container (a runtime entity of a given type),
-     * optionally within a session, with an owner and initial property values.
-     * Subject to the type's `instantiableBy` rule (`admin | member | owner`).
-     *
-     * @param input - {@link CreateContainerInput}: `appId` (decimal string), an
-     *   optional `sessionId` (omit for an app-global container), the `typeName` to
-     *   instantiate, a `displayName`, optional `description`, optional
-     *   `ownerUserId` (decimal string; defaults to the caller for member/owner
-     *   instantiation), optional `metadataJson` (JSON-object string), and optional
-     *   initial `properties` (each `{ key, valueType, valueJson }` with a
-     *   JSON-encoded value).
-     * @returns The created {@link GmContainer}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` if `instantiableBy` disallows the caller, `NOT_FOUND` for an
-     *   unknown type, or `BAD_USER_INPUT` for malformed properties.
-     */
-    createContainer(input: GameModelCreateContainerMutationVariables['input']): Promise<GameModelCreateContainerMutation['gameModelCreateContainer']>;
-    /**
-     * **Containers** — delete a container instance. Cascades its instance
-     * properties and any edges connected to it. Allowed for an app admin or the
-     * container owner. **Destructive.**
-     *
-     * @param variables - `{ appId, containerId }`: `appId` (decimal string) and
-     *   the container UUID to delete.
-     * @returns `true` if a container was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` if the caller is neither an app admin nor the owner.
-     */
-    deleteContainer(variables: GameModelDeleteContainerMutationVariables): Promise<GameModelDeleteContainerMutation['gameModelDeleteContainer']>;
-    /**
-     * **Containers** — set a single property value on a container directly (outside
-     * a function). Allowed only when the property's `writable` rule
-     * (`function | owner | admin`) permits the caller; the value is JSON-encoded
-     * and coerced to the property's declared value type. For game-logic changes
-     * prefer {@link invoke}, which enforces an authority policy and logs an event.
-     *
-     * @param input - {@link SetContainerPropertyInput}: `appId` (decimal string),
-     *   `containerId`, the property `key`, its `valueType` (must match the property
-     *   definition), and `valueJson` (the JSON-encoded value to write).
-     * @returns The updated {@link GmContainer}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` if the property's `writable` rule forbids a direct write,
-     *   `NOT_FOUND` for an unknown container/property, or `BAD_USER_INPUT` for a
-     *   value-type mismatch.
-     */
-    setProperty(input: GameModelSetPropertyMutationVariables['input']): Promise<GameModelSetPropertyMutation['gameModelSetProperty']>;
-    /**
-     * **Edges** — create a directed relationship edge between two containers (the
-     * game model is a graph), with a relationship type and optional weight.
-     *
-     * @param input - {@link AddEdgeInput}: `appId` (decimal string),
-     *   `fromContainerId` (source) and `toContainerId` (target), a
-     *   `relationshipType` label, an optional numeric `weight`, and optional
-     *   `metadataJson` (JSON-object string).
-     * @returns The created {@link GmEdge} (`edgeId`, endpoints, type, weight).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `NOT_FOUND` if either container is unknown, or `BAD_USER_INPUT`.
-     */
-    addEdge(input: GameModelAddEdgeMutationVariables['input']): Promise<GameModelAddEdgeMutation['gameModelAddEdge']>;
-    /**
-     * **Edges** — delete a directed relationship edge. Allowed for an app admin or
-     * the owner of the source (`from`) container. **Destructive.**
-     *
-     * @param variables - `{ appId, edgeId }`: `appId` (decimal string) and the
-     *   edge UUID to delete.
-     * @returns `true` if an edge was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` if the caller may not delete the edge.
-     */
-    deleteEdge(variables: GameModelDeleteEdgeMutationVariables): Promise<GameModelDeleteEdgeMutation['gameModelDeleteEdge']>;
-    /**
-     * **Functions** — invoke a studio-defined function against a `self` container
-     * with JSON params. This is the primary, *safe* way for players to mutate game
-     * state: the server enforces the function's invoke policy (the 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, and logs an {@link events | event}. Only `player`-scope functions
-     * are invocable here.
-     *
-     * Note: an authority denial or an expression-evaluation error is **not** a
-     * thrown exception — it comes back as a resolved result with `success: false`
-     * and `fault.code` (`NOT_ALLOWED` for a policy refusal). Inspect
-     * `result.success` rather than relying on `try/catch` for those cases.
-     *
-     * **The invoke policy applies to app admins too** (ck-api v1.89.0). Your own
-     * account, testing your own game, is judged exactly like a player's. Before
-     * that release a `manage_apps` holder skipped every policy implicitly, which
-     * made policies look unenforced to the people who wrote them. Administrative
-     * tooling that needs to run a function regardless of its policy sets
-     * `bypassPolicy: true`: honoured only with `manage_apps` (a GraphQL
-     * `NOT_ALLOWED` error otherwise, nothing runs), reported back as
-     * `policyBypassed: true` on the result, and audit-logged server-side.
-     *
-     * @param input - {@link InvokeFunctionInput}: `appId` (decimal string), the
-     *   `functionName`, the `selfContainerId` (the container the function runs
-     *   against, referenced as `self` in expressions), an optional `sessionId`
-     *   context, `paramsJson` (a JSON-object string of params), and the optional
-     *   administrative `bypassPolicy` flag described above.
-     * @returns A {@link GmInvokeResult}: `success`, the logged `eventId`, the
-     *   JSON-encoded `returnValueJson`, the `mutationsApplied` (each with
-     *   before/after JSON values), `fault` when `success` is `false`, and
-     *   `policyBypassed` when the call skipped the policy on purpose.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `NOT_FOUND` for an unknown function/container, `FORBIDDEN` if the function
-     *   isn't `player`-scope, `NOT_ALLOWED` for `bypassPolicy` without
-     *   `manage_apps`, or `BAD_USER_INPUT` for malformed params. (Authority and
-     *   evaluation failures surface as `success: false`, see above.)
-     */
-    invoke(input: GameModelInvokeMutationVariables['input']): Promise<GameModelInvokeMutation['gameModelInvoke']>;
-    /**
-     * **Containers** — fetch one container (instance) by id, with its full record
-     * (unfiltered metadata). For a player-facing view whose property values are
-     * filtered to what the caller may see, use {@link containerState} instead.
-     *
-     * @param variables - `{ appId, containerId }`: `appId` (decimal string) is the
-     *   owning app and `containerId` is the container UUID to fetch.
-     * @returns The {@link GmContainer}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if no such container.
-     */
-    container(variables: GameModelContainerQueryVariables): Promise<GameModelContainerQuery['gameModelContainer']>;
-    /**
-     * **Containers** — list containers in an app, optionally narrowed by container
-     * type and/or session, filtered by property predicates, and paged.
-     *
-     * @param variables - `{ appId, typeName?, sessionId?, where?, limit?, offset? }`:
-     *   `appId` (decimal string); optional `typeName` (omit for all types);
-     *   optional `sessionId` (omit for all containers, including app-global
-     *   ones); optional `where` (max 8 AND-combined
-     *   `{ key, op, valueJson }` predicates — ops `==`, `!=`, `<`, `>`, `<=`,
-     *   `>=`; requires `typeName`; missing properties fall back to the type
-     *   default — the same predicate shape automation selectors use); optional
-     *   `limit`/`offset` paging applied after filtering over the stable
-     *   created-at ordering. `bindingKey` narrows to the one row ensured (or
-     *   seeded) under that key — with `typeName` and `sessionId` it is the
-     *   get-by-key read. **An omitted `limit` returns 200 rows and the
-     *   maximum is 1,000** (`BAD_REQUEST` above it); without `where` the page is
-     *   read in SQL, with `where` the predicates are evaluated after reading at
-     *   most 10,000 rows of the type and a larger type is refused. Requires
-     *   game-api with container predicates (2026-07 or later); older servers
-     *   reject the new arguments.
-     * @returns The matching {@link GmContainer}s.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `BAD_USER_INPUT` for `where` without `typeName` / unsupported ops.
-     */
-    containers(variables: GameModelContainersQueryVariables): Promise<GameModelContainersQuery['gameModelContainers']>;
-    /**
-     * **Containers** — fetch a container together with its property values
-     * filtered to what the **calling** user is allowed to see (`public` always;
-     * `owner`/`hidden` depend on the caller's relationship to the container). Use
-     * this for a player-facing view of an entity.
-     *
-     * @param variables - `{ appId, containerId }`: `appId` (decimal string) and
-     *   the `containerId` UUID whose visible state to fetch.
-     * @returns A {@link GmContainerState}; its `propertiesJson` is a JSON-object
-     *   string of the properties visible to the caller (`JSON.parse` it).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if no such container.
-     */
-    containerState(variables: GameModelContainerStateQueryVariables): Promise<GameModelContainerStateQuery['gameModelContainerState']>;
-    /**
-     * **Containers** — the bulk twin of {@link containerState}: identity plus the
-     * property state visible to the **calling** user for up to **500** containers
-     * in one call, with the same per-row visibility rules. Ids the app does not
-     * hold are omitted rather than errors, duplicates come back once, and the
-     * order follows the input. After paging {@link containers} (default 200, max
-     * 1,000 per page), two of these pull a page's state — a level of thousands of
-     * placed objects loads in a handful of calls instead of one per object.
-     *
-     * @param variables - `{ appId, containerIds }`: `appId` (decimal string) and
-     *   up to 500 container UUIDs.
-     * @returns An array of {@link GmContainerState}; each `propertiesJson` is a
-     *   JSON-object string of the properties visible to the caller.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `BAD_REQUEST` for more than 500 ids or a non-UUID id.
-     */
-    containerStates(variables: GameModelContainerStatesQueryVariables): Promise<GameModelContainerStatesQuery['gameModelContainerStates']>;
-    /**
-     * **Edges** — traverse the container graph from a root container along a
-     * relationship type up to a given depth, returning the reachable nodes and the
-     * edges between them.
-     *
-     * @param variables - `{ appId, rootId, relationshipType, depth? }`: `appId`
-     *   (decimal string); the `rootId` container UUID to start from; the
-     *   `relationshipType` edge label to follow; and optional `depth`, the number
-     *   of edge hops to follow from the root (defaults to `1`).
-     * @returns A {@link GmTraverseResult}: the `rootId`, the reachable `nodes`
-     *   ({@link GmContainer}[]), and the traversed `edges` ({@link GmEdge}[]).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if the root container is unknown.
-     */
-    traverse(variables: GameModelTraverseQueryVariables): Promise<GameModelTraverseQuery['gameModelTraverse']>;
-    /**
-     * **Sessions** — fetch one session by id.
-     *
-     * @param variables - `{ appId, sessionId }`: `appId` (decimal string) and the
-     *   `sessionId` to fetch.
-     * @returns The {@link GmSession}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `NOT_FOUND` if no such session.
-     */
-    session(variables: GameModelSessionQueryVariables): Promise<GameModelSessionQuery['gameModelSession']>;
-    /**
-     * **Sessions** — list sessions in an app, newest first, optionally filtered
-     * by `status` (`active | completed | abandoned`), `admission`
-     * (`open | locked | closed` — `'open'` lists joinable lobbies) and/or
-     * `hostUserId`.
-     *
-     * @param variables - `{ appId, status?, admission?, hostUserId?, limit? }`
-     *   (`limit` defaults to 200, max 1000).
-     * @returns The matching {@link GmSession}s.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    sessions(variables: GameModelSessionsQueryVariables): Promise<GameModelSessionsQuery['gameModelSessions']>;
-    /**
-     * **Sessions** — the authoritative state of one session at one revision: the
-     * session row and every *joined* participant. Pull it when you subscribe
-     * with {@link sessionChanged}, after a reconnect, or when the stream shows a
-     * revision gap; then apply only events whose `revision` is above
-     * `snapshot.revision`.
-     *
-     * @param variables - `{ appId, sessionId }`.
-     * @returns `{ revision, session, participants }`.
-     * @throws {CrowdyGraphQLError} `NOT_FOUND`, `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    sessionSnapshot(variables: GameModelSessionSnapshotQueryVariables): Promise<GameModelSessionSnapshotQuery['gameModelSessionSnapshot']>;
-    /**
-     * **Sessions** — the events of a session with a revision strictly greater
-     * than `afterRevision`, oldest first: the gap-fill read behind
-     * {@link sessionChanged}. Events of ended sessions are retained for a bounded
-     * period, then purged.
-     *
-     * @param variables - `{ appId, sessionId, afterRevision, limit? }`;
-     *   `afterRevision` is a decimal string (`'0'` for everything retained).
-     * @returns The matching {@link GmSessionEvent}s.
-     */
-    sessionEvents(variables: GameModelSessionEventsQueryVariables): Promise<GameModelSessionEventsQuery['gameModelSessionEvents']>;
-    /**
-     * **Sessions (operators)** — the full roster including departed participants
-     * (with `leftReason` and `incarnation`), each joined participant's live
-     * presence verdict (`fresh | grace | stale | legacy | left`), and the most
-     * recent events. Requires app-admin (`manage_apps`).
-     *
-     * @param variables - `{ appId, sessionId }`.
-     * @throws {CrowdyGraphQLError} `FORBIDDEN` without `manage_apps`.
-     */
-    sessionInspect(variables: GameModelSessionInspectQueryVariables): Promise<GameModelSessionInspectQuery['gameModelSessionInspect']>;
-    /**
-     * **Events** — query the function-invocation event log (audit trail) with
-     * optional filters and pagination. Useful for debugging functions or showing
-     * recent activity.
-     *
-     * @param variables - `{ appId, sessionId?, selfContainerId?, functionName?,
-     *   success?, limit?, offset? }`: `appId` (decimal string); optional
-     *   `sessionId`; optional `selfContainerId` (the UUID the function ran
-     *   against); optional `functionName`; optional `success` (`true` = succeeded,
-     *   `false` = failed). `limit` (page size) and `offset` (rows to skip) are
-     *   **deprecated** — see below.
-     * @returns The matching {@link GmEvent}s (each with `paramsJson`,
-     *   `mutationsAppliedJson`, `returnValueJson`, `success`, `errorMessage`, and
-     *   `executedAt`).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     * @remarks The `limit`/`offset` fields use deprecated offset pagination. For
-     *   large logs prefer the Relay-style `gameModelEventsConnection(first:, after:)`
-     *   cursor query (available on the schema via `client.graphql`). See
-     *   https://docs.crowdedkingdoms.com/overview/pagination.
-     */
-    events(variables: GameModelEventsQueryVariables): Promise<GameModelEventsQuery['gameModelEvents']>;
-    /**
-     * **Events** — Relay-style cursor pagination over the function-invocation
-     * event log; the preferred alternative to {@link events} for large logs. Page
-     * with `first` plus the previous page's `pageInfo.endCursor` as `after`. See
-     * https://docs.crowdedkingdoms.com/overview/pagination.
-     *
-     * @param variables - `{ appId, first?, after?, sessionId?, selfContainerId?,
-     *   functionName?, success? }`.
-     * @returns A {@link GameModelEventsConnection} (`edges { cursor node }`,
-     *   `pageInfo`, `totalCount`).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`.
-     */
-    eventsConnection(variables: GameModelEventsConnectionQueryVariables): Promise<GameModelEventsConnectionQuery['gameModelEventsConnection']>;
-    /**
-     * **Diagnostics** — stitch one flow correlation id into a single
-     * cross-engine timeline: the model **events** ({@link events} rows), the
-     * **automationRuns**, and the compute **moduleRuns** that share the
-     * `flowId` minted at the entry edge (a player {@link invoke}, an automation
-     * run, or a `computeInvoke`) and propagated across `model_invoke`, the
-     * event bus, and `emit_compute_event`. Each array is ordered by time
-     * ascending, so the three together read as one causal trace — "what
-     * happened to this kill's reward" in one query instead of three
-     * hand-joined ones. Take the `flowId` from the `flowId` field on any
-     * {@link GmEvent}, {@link GmAutomationRun}, or {@link WasmModuleRun}
-     * (selected by the default fragments since SDK 8.13.0).
-     *
-     * Requires the app-admin **`manage_apps`** permission (a diagnostics
-     * surface, like {@link automationRuns}) and a game-api with the
-     * `gameModelFlow` query (2026-07-19 or later; older servers reject the
-     * operation with a validation error).
-     *
-     * @param variables - `{ appId, flowId }`: `appId` (decimal string) and the
-     *   flow correlation id (a UUID string). An unknown `flowId` returns three
-     *   empty arrays.
-     * @returns The {@link GmFlowTimeline}: `flowId`, `events`,
-     *   `automationRuns`, and `moduleRuns`, each time-ascending.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_REQUEST`
-     *   if `flowId` is not a UUID.
-     */
-    flow(variables: GameModelFlowQueryVariables): Promise<GameModelFlowQuery['gameModelFlow']>;
-    /**
-     * **Seed** — bulk-create game-model definitions (container types, property
-     * defs, functions) and optionally instances (containers + edges) in one
-     * transaction; used to initialize or import a model.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link SeedGameModelInput}: `appId` (decimal string); an
-     *   optional `sessionId` to seed instances into (omit/`null` = app-global);
-     *   and arrays of `containerTypes`, `propertyDefinitions`, `functions`,
-     *   `containers`, and `edges` to create. Seed containers carry a developer
-     *   `tempId`; seed edges reference containers by those temp ids
-     *   (`fromTempId`/`toTempId`). A container may name its own `bindingKey`
-     *   (on a type that is `instantiableBy: 'admin'` or carries a `bindPolicyJson`,
-     *   and not beginning with `seed:`) so a runtime `gameModelEnsureContainer` later
-     *   resolves the same row; otherwise it binds as `seed:` + `tempId`. A
-     *   caller-keyed row that already exists is adopted only if its `ownerUserId`
-     *   matches (a re-seed); a row a player claimed first is refused and nothing
-     *   is written. At most
-     *   **1,000 containers per call**, all-or-nothing; the same key on two types
-     *   is two rows. A container type may declare `scope: 'app'` (one row per key
-     *   for the whole app) or `'session'` (default). Seeded rows fire no
-     *   `container_created` automation triggers or change-feed events.
-     * @returns A {@link GmSeedResult}: the counts created, non-fatal `warnings`,
-     *   and `idMapJson` — a JSON-object string mapping each seed `tempId` to the
-     *   created container UUID (`JSON.parse` it to wire up follow-up calls).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (with `extensions.requiredPermission === 'manage_apps'`) if the
-     *   caller lacks app-admin, or `BAD_USER_INPUT` for malformed definitions.
-     */
-    seed(input: GameModelSeedMutationVariables['input']): Promise<GameModelSeedMutation['gameModelSeed']>;
-    /**
-     * **Container types** — create or update a container type: the studio-defined
-     * schema for a kind of runtime entity (like a class). Idempotent on
-     * `(appId, typeName)`.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertContainerTypeInput}: `appId` (decimal string);
-     *   the `typeName` (the stable upsert key, unique per app); a `displayName`;
-     *   optional `description`; optional `instantiableBy` (`admin | member |
-     *   owner`); optional `defaultPropertyVisibility` (`public | owner | hidden`);
-     *   optional `bindPolicyJson` (who may claim a `bindingKey` on
-     *   `ensureContainer`; omit to leave the type unbound); optional `scope`
-     *   (`'session'` default — one row per key per session; `'app'` — one row
-     *   per key for the whole app, on which `ensureContainer` /
-     *   `createContainer` with a `sessionId` are refused with
-     *   `CONTAINER_TYPE_APP_SCOPED`; changing to `'app'` is refused while the
-     *   type holds session-scoped rows); and optional `metadataJson`
-     *   (JSON-object string).
-     * @returns The upserted {@link GmContainerType}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`.
-     */
-    upsertContainerType(input: GameModelUpsertContainerTypeMutationVariables['input']): Promise<GameModelUpsertContainerTypeMutation['gameModelUpsertContainerType']>;
-    /**
-     * **Property definitions** — create or update a typed property on a container
-     * type (a field with a default value, read visibility, and writability).
-     * Idempotent on `(appId, containerTypeName, key)`.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertPropertyDefInput}: `appId` (decimal string); the
-     *   `containerTypeName` to define on; the property `key` (part of the upsert
-     *   key); a `valueType` (`int | float | string | bool | array | object |
-     *   container_ref`); optional `defaultValueJson` (JSON-encoded default);
-     *   optional `visibility` (`public | owner | hidden`); optional `writable`
-     *   (`function | owner | admin`); and optional `description`.
-     * @returns The upserted {@link GmPropertyDef}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), `NOT_FOUND` for an
-     *   unknown container type, or `BAD_USER_INPUT`.
-     */
-    upsertPropertyDef(input: GameModelUpsertPropertyDefMutationVariables['input']): Promise<GameModelUpsertPropertyDefMutation['gameModelUpsertPropertyDef']>;
-    /**
-     * **Property definitions** — delete a property definition from a container
-     * type. Does **not** remove instance property values already stored on
-     * containers. **Destructive.**
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, containerTypeName, key }`.
-     * @returns `true` if a definition was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`).
-     */
-    deletePropertyDef(variables: GameModelDeletePropertyDefMutationVariables): Promise<GameModelDeletePropertyDefMutation['gameModelDeletePropertyDef']>;
-    /**
-     * **Container types** — delete a container type and its property definitions.
-     * Refuses if live containers of that type exist, or if functions are bound to
-     * it — delete those first. **Destructive.**
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, typeName }`.
-     * @returns `true` if a type was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`
-     *   when containers or bound functions still exist.
-     */
-    deleteContainerType(variables: GameModelDeleteContainerTypeMutationVariables): Promise<GameModelDeleteContainerTypeMutation['gameModelDeleteContainerType']>;
-    /**
-     * **Functions** — create or update a studio-defined function: a named,
-     * sandboxed behaviour with typed parameters, declared property mutations
-     * (expressions compiled to an AST server-side — never `eval`'d), an optional
-     * return expression, an invoke scope, and an invoke policy (authority rule
-     * tree). Idempotent on `(appId, name)`. Players run these via {@link invoke}.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertFunctionInput}: `appId` (decimal string); the
-     *   `name` (upsert key, used to invoke it); optional `containerTypeName` to
-     *   bind to (omit for a global function); optional `description`; optional
-     *   `returnType`; `parameters` (typed `{ name, valueType, required?,
-     *   defaultValueJson?, … }`); `mutations` (declared writes `{ target, property,
-     *   expression }`, applied atomically); optional `returnExpression`;
-     *   `invokeScope` (`player | server | internal`); and `invokePolicyJson` (a
-     *   JSON-encoded authority rule tree).
-     * @returns The upserted {@link GmFunction}, including any non-fatal
-     *   static-analysis `warnings` from this upload.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`
-     *   for an expression/policy that fails to compile.
-     */
-    upsertFunction(input: GameModelUpsertFunctionMutationVariables['input']): Promise<GameModelUpsertFunctionMutation['gameModelUpsertFunction']>;
-    /**
-     * **Functions** — delete a studio-defined function by name. **Destructive.**
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name }`: `appId` (decimal string) and the
-     *   function `name` to delete.
-     * @returns `true` if a function was deleted, `false` if none matched.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`, or
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`) if the caller lacks
-     *   app-admin.
-     */
-    deleteFunction(variables: GameModelDeleteFunctionMutationVariables): Promise<GameModelDeleteFunctionMutation['gameModelDeleteFunction']>;
-    /**
-     * **App features** — define an app feature key that functions can gate on (via
-     * a `tier_feature` authority rule) and that access tiers can be granted.
-     * Idempotent on `(appId, featureKey)`.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link DefineAppFeatureInput}: `appId` (decimal string); the
-     *   `featureKey` (referenced by `tier_feature` rules); and an optional
-     *   `description`.
-     * @returns The defined {@link GmAppFeature}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`.
-     */
-    defineFeature(input: GameModelDefineFeatureMutationVariables['input']): Promise<GameModelDefineFeatureMutation['gameModelDefineFeature']>;
-    /**
-     * **App features** — grant a feature key to an access tier, so users on that
-     * tier satisfy `tier_feature` authority checks for it.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link GrantTierFeatureInput}: `appId` (decimal string); the
-     *   `tierId` (decimal string) of the access tier; and the `featureKey` to
-     *   grant to that tier.
-     * @returns The {@link GmTierFeature} grant record.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `NOT_FOUND` for an
-     *   unknown tier/feature.
-     */
-    grantTierFeature(input: GameModelGrantTierFeatureMutationVariables['input']): Promise<GameModelGrantTierFeatureMutation['gameModelGrantTierFeature']>;
-    /**
-     * **Policy** — set the app's game-model runtime policy: who may create
-     * sessions and the default role assigned to new session participants.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link SetGameModelPolicyInput}: `appId` (decimal string); an
-     *   optional `sessionCreationPolicy` (`admin | member | anyone`); and an
-     *   optional `defaultParticipantRole`.
-     * @returns The updated {@link GmAppPolicy}.
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `BAD_USER_INPUT`.
-     */
-    setPolicy(input: GameModelSetPolicyMutationVariables['input']): Promise<GameModelSetPolicyMutation['gameModelSetPolicy']>;
-    /**
-     * **Container types** — fetch a container type's full schema: its property
-     * definitions plus the functions available on it. A studio/authoring read.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, typeName }`: `appId` (decimal string) and the
-     *   `typeName` whose schema to fetch.
-     * @returns A {@link GmTypeSchema}: the `typeName`, its `propertyDefinitions`
-     *   ({@link GmPropertyDef}[]), and its `functions` ({@link GmFunction}[]).
-     * @throws {CrowdyGraphQLError} `UNAUTHENTICATED` / `SCOPE_MISSING`,
-     *   `FORBIDDEN` (`requiredPermission === 'manage_apps'`), or `NOT_FOUND` for an
-     *   unknown type.
-     */
-    typeSchema(variables: GameModelTypeSchemaQueryVariables): Promise<GameModelTypeSchemaQuery['gameModelTypeSchema']>;
-    /**
-     * **Container types** — list every container type defined for an app. A
-     * studio/authoring read. Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The app's {@link GmContainerType}s.
-     */
-    containerTypes(variables: GameModelContainerTypesQueryVariables): Promise<GameModelContainerTypesQuery['gameModelContainerTypes']>;
-    /**
-     * **Property definitions** — list the property definitions for one container
-     * type. A studio/authoring read. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, typeName }`.
-     * @returns The type's {@link GmPropertyDef}s.
-     */
-    propertyDefs(variables: GameModelPropertyDefsQueryVariables): Promise<GameModelPropertyDefsQuery['gameModelPropertyDefs']>;
-    /**
-     * **Functions** — fetch one studio-defined function by name (including its
-     * parameters, mutations, and notification effects). Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns The {@link GmFunction}.
-     */
-    getFunction(variables: GameModelFunctionQueryVariables): Promise<GameModelFunctionQuery['gameModelFunction']>;
-    /**
-     * **Functions** — list studio-defined functions for an app, optionally
-     * filtered to those bound to a container type. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, containerTypeName? }`.
-     * @returns The matching {@link GmFunction}s.
-     */
-    functions(variables: GameModelFunctionsQueryVariables): Promise<GameModelFunctionsQuery['gameModelFunctions']>;
-    /**
-     * **App features** — list the feature keys defined for an app. Requires the
-     * app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The app's {@link GmAppFeature}s.
-     */
-    features(variables: GameModelFeaturesQueryVariables): Promise<GameModelFeaturesQuery['gameModelFeatures']>;
-    /**
-     * **App features** — list tier→feature grants for an app, optionally filtered
-     * to one tier. Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, tierId? }`.
-     * @returns The {@link GmTierFeature} grants.
-     */
-    tierFeatures(variables: GameModelTierFeaturesQueryVariables): Promise<GameModelTierFeaturesQuery['gameModelTierFeatures']>;
-    /**
-     * **App features** — revoke a feature key from an access tier (the inverse of
-     * {@link grantTierFeature}). Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param input - {@link GrantTierFeatureInput} (`appId`, `tierId`, `featureKey`).
-     * @returns `true` if a grant was removed.
-     */
-    revokeTierFeature(input: GameModelRevokeTierFeatureMutationVariables['input']): Promise<GameModelRevokeTierFeatureMutation['gameModelRevokeTierFeature']>;
-    /**
-     * **Policy** — read the app's game-model runtime policy (session-creation
-     * policy + default participant role). Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAppPolicy}.
-     */
-    policy(variables: GameModelPolicyQueryVariables): Promise<GameModelPolicyQuery['gameModelPolicy']>;
-    /**
-     * **Automations** — create or update an autonomous process ("automation" /
-     * NPC): a server-driven entry-point function bound to a trigger
-     * (`schedule | event | manual`), an optional run-as identity, a target/
-     * candidate selector, and a per-automation safety budget. The entry-point
-     * function must be marked `autonomousInvocable` (see {@link upsertFunction}).
-     * Idempotent on `(appId, name)`. The game-api dispatcher runs it headlessly;
-     * a tick is just "invoke a function on behalf of the server".
-     *
-     * **Only while the app has a player in it** (2026-09-01). A scheduled
-     * automation that comes due while the app is empty is skipped silently and
-     * rescheduled from the moment a player returns; the missed runs are never made
-     * up. Write the entry point so it is idempotent in ELAPSED TIME -- advance the
-     * world by `now - lastRun` rather than by one step per tick -- or it will
-     * silently fall behind whenever nobody is playing. `event` and `manual`
-     * triggers are unaffected: something already asked for those.
-     *
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link UpsertAutomationInput}: `appId`; `name` (upsert key);
-     *   the action — `actionKind: 'model_function'` (default) with
-     *   `functionName`, or `actionKind: 'compute_invoke'` with
-     *   `computeModuleName` + `computeExport` (invokes a compute-module invoke
-     *   export on the trusted server path; `targetMode` forced to `global`,
-     *   selectors don't apply — requires game-api 2026-07+); `targetMode`
-     *   (`container | type | global`) with `selfContainerId` /
-     *   `targetTypeName`; optional `sessionId`, `paramsJson`, `selectorJson`
-     *   (model-data candidate selection), `runAsUserId`; the trigger
-     *   (`triggerType`, `scheduleKind`, `intervalMs` / `cronExpr`); and the safety
-     *   budget (`maxTargets`, `maxFnDepth`, `gasLimit`, `runTimeoutMs`,
-     *   `maxRunsPerMinute`, `failureThreshold`, `cooldownMs`).
-     * @returns The upserted {@link GmAutomation}, including circuit-breaker state.
-     */
-    upsertAutomation(input: GameModelUpsertAutomationMutationVariables['input']): Promise<GameModelUpsertAutomationMutation['gameModelUpsertAutomation']>;
-    /**
-     * **Automations** — delete an automation by name (also removes its event
-     * triggers). **Destructive.** Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns `true` if one was deleted.
-     */
-    deleteAutomation(variables: GameModelDeleteAutomationMutationVariables): Promise<GameModelDeleteAutomationMutation['gameModelDeleteAutomation']>;
-    /**
-     * **Automations** — enable or disable an automation. Re-enabling also resets
-     * its circuit breaker so a tripped automation resumes. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name, enabled }`.
-     * @returns The updated {@link GmAutomation}.
-     */
-    setAutomationEnabled(variables: GameModelSetAutomationEnabledMutationVariables): Promise<GameModelSetAutomationEnabledMutation['gameModelSetAutomationEnabled']>;
-    /**
-     * **Automations** — create an event trigger that fires an automation in
-     * reaction to model activity (`function_invoked` | `property_changed` |
-     * `container_created` | `player_count_changed`), matched in the API server
-     * post-commit. Requires the app-admin **`manage_apps`** permission.
-     *
-     * Each event matches on its own filters, and a filter the event does not
-     * match on is rejected rather than silently never firing:
-     * `function_invoked` takes `functionName` and `containerTypeName` (the type
-     * of the invocation's `self` container); `property_changed` takes
-     * `containerTypeName`, `propertyKey`, and `writeSource`;
-     * `container_created` takes `containerTypeName`; `player_count_changed`
-     * takes none.
-     *
-     * `writeSource` decides which writes a `property_changed` trigger sees:
-     * `direct` (a {@link GameModelAPI.setProperty} call), `function` (a mutation
-     * applied inside an invoke, automation run, or timer fire), or `any`
-     * (default). Most game logic writes properties from inside functions, so a
-     * trigger watching such a property needs `function` or `any`.
-     *
-     * @param input - {@link UpsertAutomationTriggerInput}: `appId`,
-     *   `automationName`, `onEvent`, the filters valid for that event, and
-     *   `debounceMs`.
-     * @returns The created {@link GmAutomationTrigger}.
-     */
-    upsertAutomationTrigger(input: GameModelUpsertAutomationTriggerMutationVariables['input']): Promise<GameModelUpsertAutomationTriggerMutation['gameModelUpsertAutomationTrigger']>;
-    /**
-     * **Automations** — delete an event trigger by id. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, triggerId }`.
-     * @returns `true` if one was deleted.
-     */
-    deleteAutomationTrigger(variables: GameModelDeleteAutomationTriggerMutationVariables): Promise<GameModelDeleteAutomationTriggerMutation['gameModelDeleteAutomationTrigger']>;
-    /**
-     * **Automations** — set the app's automation policy (platform guardrails: the
-     * kill switch, max automations, the minimum schedule interval floor, max
-     * fan-out, max event cascade depth, the aggregate per-minute run ceiling, and
-     * the timer floor / pending-timer ceiling).
-     * Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param input - {@link SetAutomationPolicyInput}.
-     * @returns The updated {@link GmAutomationPolicy}.
-     */
-    setAutomationPolicy(input: GameModelSetAutomationPolicyMutationVariables['input']): Promise<GameModelSetAutomationPolicyMutation['gameModelSetAutomationPolicy']>;
-    /**
-     * **Automations** — run an automation once, immediately (manual trigger),
-     * regardless of its schedule. Applies the same guard chain and records a run.
-     * Useful for testing an NPC. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns The recorded {@link GmAutomationRun}.
-     */
-    runAutomation(variables: GameModelRunAutomationMutationVariables): Promise<GameModelRunAutomationMutation['gameModelRunAutomation']>;
-    /**
-     * **Automations** — list the automations defined for an app (with
-     * circuit-breaker state). Requires the app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAutomation}s.
-     */
-    automations(variables: GameModelAutomationsQueryVariables): Promise<GameModelAutomationsQuery['gameModelAutomations']>;
-    /**
-     * **Automations** — fetch one automation by name. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, name }`.
-     * @returns The {@link GmAutomation}.
-     */
-    automation(variables: GameModelAutomationQueryVariables): Promise<GameModelAutomationQuery['gameModelAutomation']>;
-    /**
-     * **Automations** — list event triggers for an app, optionally filtered to one
-     * automation by name. Requires the app-admin **`manage_apps`** permission.
-     *
-     * Use this to debug a trigger that isn't firing: `warnings` reports filters
-     * that can never match, `lastMatchedAt` is null until the trigger has
-     * actually dispatched a run, and `matchCount24h` shows recent activity.
-     *
-     * @param variables - `{ appId, automationName? }`.
-     * @returns The {@link GmAutomationTrigger}s.
-     */
-    automationTriggers(variables: GameModelAutomationTriggersQueryVariables): Promise<GameModelAutomationTriggersQuery['gameModelAutomationTriggers']>;
-    /**
-     * **Automations** — read the app's automation policy. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAutomationPolicy}.
-     */
-    automationPolicy(variables: GameModelAutomationPolicyQueryVariables): Promise<GameModelAutomationPolicyQuery['gameModelAutomationPolicy']>;
-    /**
-     * **Automations** — list automation runs (the monitoring/audit trail), newest
-     * first, optionally filtered by automation name and/or outcome. Requires the
-     * app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, automationName?, success?, limit?, offset? }`.
-     * @returns The {@link GmAutomationRun}s.
-     */
-    automationRuns(variables: GameModelAutomationRunsQueryVariables): Promise<GameModelAutomationRunsQuery['gameModelAutomationRuns']>;
-    /**
-     * **Automations** — aggregate automation activity over a recent window
-     * (throughput, failure rate, compute, per-automation breakdown). The
-     * "what are my NPCs doing" view. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, windowMinutes? }` (default 60, max 1440).
-     * @returns The {@link GmAutomationStats}.
-     */
-    automationStats(variables: GameModelAutomationStatsQueryVariables): Promise<GameModelAutomationStatsQuery['gameModelAutomationStats']>;
-    /**
-     * **Diagnostics** — a snapshot of an app's game-model footprint and recent
-     * activity (row counts + 24h invocation activity + top functions). Helps
-     * developers understand what is in their game and their database. Requires the
-     * app-admin **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId }`.
-     * @returns The {@link GmAppDiagnostics}.
-     */
-    appDiagnostics(variables: GameModelAppDiagnosticsQueryVariables): Promise<GameModelAppDiagnosticsQuery['gameModelAppDiagnostics']>;
-    /**
-     * **Timers** — arm a one-shot timer: invoke a function once, after a delay.
-     * The timer is durable (it survives an API restart) and claimed by exactly one
-     * replica, so it fires once. Requires the app-admin **`manage_apps`**
-     * permission, because a timer fires headlessly with system authority rather
-     * than a player's.
-     *
-     * A timer whose deadline passes while the app has no players **waits** rather
-     * than firing into an empty world: the sweep only claims timers for apps with a
-     * player present, so it is still armed and fires when somebody returns. It is
-     * therefore late, not lost -- read the current time in the handler rather than
-     * assuming the delay you asked for is the delay that elapsed.
-     *
-     * For player-driven delays, declare a `timers` effect on the function instead
-     * (see {@link GameModelAPI.upsertFunction}) so the delay is part of your game
-     * logic and is armed atomically with that invocation's mutations.
-     *
-     * The target function must be `autonomousInvocable`. Pass `dedupeKey` to make
-     * re-arming replace the pending timer instead of queueing another fire, which
-     * is how you implement "reset the countdown".
-     *
-     * @param input - {@link ScheduleInvokeInput}: `appId`, `functionName`,
-     *   `selfContainerId`, `delayMs`, and optional `paramsJson`, `sessionId`, and
-     *   `dedupeKey`.
-     * @returns The armed {@link GmTimer}.
-     */
-    scheduleInvoke(input: GameModelScheduleInvokeMutationVariables['input']): Promise<GameModelScheduleInvokeMutation['gameModelScheduleInvoke']>;
-    /**
-     * **Timers** — cancel pending timers by id or by dedupe key. A timer already
-     * claimed for execution cannot be cancelled. Requires the app-admin
-     * **`manage_apps`** permission.
-     *
-     * @param variables - `{ appId, timerId?, dedupeKey? }` (supply at least one
-     *   selector).
-     * @returns How many pending timers were removed.
-     */
-    cancelTimer(variables: GameModelCancelTimerMutationVariables): Promise<GameModelCancelTimerMutation['gameModelCancelTimer']>;
-    /**
-     * **Timers** — list pending one-shot timers, soonest first. A timer leaves
-     * this list the instant it is claimed for execution, so an empty list means
-     * nothing is *scheduled* — not that nothing ran. Fires that already happened
-     * appear in {@link GameModelAPI.automationRuns} with
-     * `triggerSource: 'timer'`. Requires the app-admin **`manage_apps`**
-     * permission.
-     *
-     * @param variables - `{ appId, sessionId?, limit? }` (limit 1-200, default 50).
-     * @returns The pending {@link GmTimer}s.
-     */
-    timers(variables: GameModelTimersQueryVariables): Promise<GameModelTimersQuery['gameModelTimers']>;
-}
-//# sourceMappingURL=gameModel.d.ts.map