import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    /** Arbitrary-precision signed integer (used for 64-bit ids and chunk coordinates such as appId, userId and chunk x/y/z). ALWAYS transmitted as a base-10 decimal STRING in BOTH directions — send it quoted (e.g. "1024", "-5") and read it back as a string; never use a raw JSON number, because large values overflow IEEE-754 doubles. The server rejects any value that is not a valid integer string. */
    BigInt: {
        input: string;
        output: string;
    };
    /** A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. */
    DateTime: {
        input: string;
        output: string;
    };
};
/** Monotonically acknowledge the highest contiguous applied event. */
export type AcknowledgeAgentEventsInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
    /** Highest contiguous applied sequence. It cannot move backward or exceed committed history. */
    throughSeq: Scalars['BigInt']['input'];
};
export type Actor = {
    __typename?: 'Actor';
    /** App (game) this actor belongs to. BigInt serialized as a decimal string. */
    appId: Scalars['BigInt']['output'];
    /** Avatar this actor is using, or null. BigInt serialized as a decimal string. */
    avatarId: Maybe<Scalars['BigInt']['output']>;
    /** Chunk-grid coordinates (x, y, z as int64 BigInt decimal strings) locating the actor in the world. */
    chunk: ChunkCoordinates;
    /** Server timestamp (ISO-8601) when the actor row was created. Used as the primary ordering key for host election (oldest fresh actor wins). */
    createdAt: Scalars['DateTime']['output'];
    /** Owner-only private state blob, base64-encoded binary. Stripped (returned null) for non-owners and in public/batch reads such as `batchLookupActors`. */
    privateState: Maybe<Scalars['String']['output']>;
    /** Public state blob, base64-encoded binary; visible to all viewers. */
    publicState: Maybe<Scalars['String']['output']>;
    /** Liveness timestamp (ISO-8601), refreshed by the `actorHeartbeat` mutation. Host election treats actors with a recent `updatedAt` as fresh; stale rows age out of eligibility. */
    updatedAt: Scalars['DateTime']['output'];
    /** Owner user id. BigInt serialized as a decimal string. Ownership gates writes and access to `privateState`. */
    userId: Scalars['BigInt']['output'];
    /** Actor id and primary key: a 32-character ASCII identifier (exactly 32 ASCII characters / 32 raw octets on the UDP wire). This is NOT a hyphenated RFC-4122 UUID. This is the value accepted by all actor `uuid` arguments. */
    uuid: Scalars['ID']['output'];
};
/** An edge in a Actor connection. */
export type ActorEdge = {
    __typename?: 'ActorEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: Actor;
};
export type ActorFilterInput = {
    /** Restrict to actors in this app. BigInt sent as a decimal string. */
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Restrict to actors using this avatar. BigInt sent as a decimal string. */
    avatarId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Restrict to actors in this chunk (x, y, z as int64 BigInt decimal strings). */
    chunk?: InputMaybe<ChunkCoordinatesInput>;
    /** Restrict to a single actor by its 32-character ASCII actor id (the UDP-wire id, not a hyphenated UUID). */
    uuid?: InputMaybe<Scalars['String']['input']>;
};
/** The signed-in identity behind a bearer token. */
export type ActorType = {
    __typename?: 'ActorType';
    /** Contributor uuid — the votes/content actor. */
    contributorUuid: Scalars['String']['output'];
    email: Maybe<Scalars['String']['output']>;
    /** Legacy bigint public user id (Buddy / CK wire), as a string. */
    userId: Scalars['String']['output'];
    /** User identity: the users.galaxy_row_uuid value. The column keeps its historical name; the datastore is PostgreSQL/Citus. */
    userUuid: Scalars['String']['output'];
    username: Maybe<Scalars['String']['output']>;
};
/** Notification received when an actor (player or NPC) state is updated by another client or the server. Received via the udpNotifications subscription. */
export type ActorUpdateNotification = {
    __typename?: 'ActorUpdateNotification';
    /** The ID of the app where the actor is located. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk where the actor is located. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk where the actor is located. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk where the actor is located. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** The actor state data, base64-encoded. Decode this to get the full ActorState containing position, rotation, velocity, animation flags, etc. */
    state: Scalars['String']['output'];
    /** The unique identifier of the actor that was updated. */
    uuid: Scalars['String']['output'];
};
/** Input for sending an actor update request to the UDP game server. This updates the state of an actor (player character or NPC) in a specific chunk. */
export type ActorUpdateRequestInput = {
    /** The ID of the app where the actor is located. */
    appId: Scalars['BigInt']['input'];
    /** The chunk coordinates where the actor is located. A chunk is a 16x16x16 voxel cube. */
    chunk: ChunkCoordinatesInput;
    /** Decay algorithm for replication: 0 = none, 1 = exponential, 2 = linear 50%, 3 = linear 25%, 4 = linear 10%, 5 = linear 5%. Defaults to 1 (exponential) for actor updates. */
    decayRate?: InputMaybe<Scalars['Int']['input']>;
    /** Chunk replication distance (0-8). Defaults to 8 for actor updates. Clamped to 0-8. */
    distance?: InputMaybe<Scalars['Int']['input']>;
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on the matching response and on any GenericErrorResponse for this send, both delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** The actor state data, base64-encoded. May be an empty string for registration-only updates (no state payload). */
    state: Scalars['String']['input'];
    /** A unique identifier for the actor. Must be exactly 32 bytes when encoded as UTF-8. This is typically a client-generated UUID. */
    uuid: Scalars['String']['input'];
};
/** LEGACY — never emitted. The game server retired the dedicated actor-update response opcode (129); an applied update now arrives as your own ActorUpdateNotification (the sender is included in the chunk fan-out) and failures arrive as GenericErrorResponse. This type remains in the UdpNotification union for backward compatibility only — do not select it in new code; it will be removed in a future major version. */
export type ActorUpdateResponse = {
    __typename?: 'ActorUpdateResponse';
    /** The ID of the app where the actor update was processed. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk where the actor is located. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk where the actor is located. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk where the actor is located. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The sequenceNumber echoed back from the originating sendActorUpdate request (a uint8, 0-255, wrapping at modulo 256). Use it to correlate this response with that send. Correlation only — not an idempotency key. */
    sequenceNumber: Scalars['Int']['output'];
    /** The unique identifier of the actor that was updated. */
    uuid: Scalars['String']['output'];
};
/** Relay-style cursor-paginated connection over the caller’s actors (Actor). Page with `first`/`after`; cursors are opaque. */
export type ActorsConnection = {
    __typename?: 'ActorsConnection';
    /** Edges on this page. */
    edges: Array<ActorEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** Create a directed edge between two containers. */
export type AddEdgeInput = {
    /** The app (tenant) that owns the containers. */
    appId: Scalars['BigInt']['input'];
    /** Source container id. */
    fromContainerId: Scalars['String']['input'];
    /** JSON object of edge metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** The relationship type label. */
    relationshipType: Scalars['String']['input'];
    /** Target container id. */
    toContainerId: Scalars['String']['input'];
    /** Optional edge weight. */
    weight?: InputMaybe<Scalars['Float']['input']>;
};
export type AdmitAppCodeInput = {
    /** Numeric app id whose allow list receives this entry. */
    appId: Scalars['BigInt']['input'];
    /** Admit one code listing, author user, or authoring org. */
    subjectKind: CodeAdmissionSubjectKind;
    /** Stable id of the subject (listing UUID, numeric user id, or numeric org id). */
    subjectRef: Scalars['String']['input'];
    /** Optional P1 version range: exact "3", inclusive "2-5", ">=4", or "<=9". Omit to admit all versions. */
    versionRange?: InputMaybe<Scalars['String']['input']>;
};
/** Short-lived single-use human decision bound to one tool call and canonical argument hash. */
export type AgentApproval = {
    __typename?: 'AgentApproval';
    /** Stable approval UUID. */
    approvalId: Scalars['String']['output'];
    /** True when this response granted/consumed the approval. */
    approved: Scalars['Boolean']['output'];
    /** Canonical sha256 argument/context binding shown to the human. */
    argumentHash: Scalars['String']['output'];
    /** Attached client epoch authorized to decide. */
    clientEpoch: Scalars['BigInt']['output'];
    /** Hard decision/consumption expiry. */
    expiresAt: Scalars['DateTime']['output'];
    /** True when this response denied the approval. */
    rejected: Scalars['Boolean']['output'];
    /** Safe bounded domain summary shown before approval. */
    safeSummary: Scalars['String']['output'];
    /** Current single-use lifecycle. */
    status: CrowdyStudioAgentApprovalStatus;
    /** Tool call UUID this decision binds. */
    toolCallId: Scalars['String']['output'];
};
/** Typed exact-argument human approval event. */
export type AgentApprovalEvent = AgentEventBase & {
    __typename?: 'AgentApprovalEvent';
    /** Stable approval UUID. */
    approvalId: Scalars['String']['output'];
    /** Canonical displayed argument hash. */
    argumentHash: Scalars['String']['output'];
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Hard approval expiry. */
    expiresAt: Scalars['DateTime']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Bounded server-authored reasons for requiring approval. */
    reasons: Array<Scalars['String']['output']>;
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Safe domain summary retained without raw arguments. */
    safeSummary: Scalars['String']['output'];
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Required approval lifecycle status. */
    status: CrowdyStudioAgentApprovalStatus;
    /** Bound tool call UUID. */
    toolCallId: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Complete platform-funded budget across turn, session, and player-day dimensions. */
export type AgentBudget = {
    __typename?: 'AgentBudget';
    /** All normative provider/tool/compile/wall-clock dimensions. */
    dimensions: Array<AgentBudgetDimension>;
    /** Payer seam; 'PLATFORM' throughout the development pilot. */
    payer: Scalars['String']['output'];
    /** True throughout the development pilot. */
    platformFunded: Scalars['Boolean']['output'];
    /** UTC player-day reset, or null when no reset applies. */
    resetAt: Maybe<Scalars['DateTime']['output']>;
};
/** One effective budget dimension at TURN, SESSION, or PLAYER_DAY scope. */
export type AgentBudgetDimension = {
    __typename?: 'AgentBudgetDimension';
    /** Durably consumed amount. */
    consumed: Scalars['BigInt']['output'];
    /** Effective hard limit. */
    limit: Scalars['BigInt']['output'];
    /** REQUESTS, INPUT_TOKENS, OUTPUT_TOKENS, REASONING_TOKENS, PROVIDER_COST, TOOL_ROUNDS, WALL_CLOCK_MS, TOOL_CALLS, or COMPILES. */
    name: Scalars['String']['output'];
    /** Non-negative remaining amount. */
    remaining: Scalars['BigInt']['output'];
    /** Worst-case active reservation. */
    reserved: Scalars['BigInt']['output'];
    /** TURN, SESSION, or PLAYER_DAY limit scope. */
    scope: Scalars['String']['output'];
    /** Dimension unit, for example tokens, requests, microusd, or ms. */
    unit: Scalars['String']['output'];
};
/** Typed provider budget reservation or reconciliation event; no wallet debit occurs in the platform-funded pilot. */
export type AgentBudgetEvent = AgentEventBase & {
    __typename?: 'AgentBudgetEvent';
    /** Complete effective budget snapshot after this change. */
    budget: AgentBudget;
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Typed immutable private project checkpoint event. */
export type AgentCheckpointEvent = AgentEventBase & {
    __typename?: 'AgentCheckpointEvent';
    /** Private checkpoint UUID. */
    checkpointId: Scalars['String']['output'];
    /** sha256 digest of the canonical private snapshot. */
    contentHash: Scalars['String']['output'];
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Bounded target/path/hash/byte summaries; never source. */
    files: Array<AgentCheckpointFile>;
    /** Project revision captured as the immutable pre-image. */
    projectRevision: Scalars['BigInt']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** AGENT_WRITE, RESTORE_PREIMAGE, or MANUAL. */
    reason: Scalars['String']['output'];
    /** Restore timestamp for CHECKPOINT_RESTORED, or null. */
    restoredAt: Maybe<Scalars['DateTime']['output']>;
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** One source-free file summary in an immutable checkpoint. */
export type AgentCheckpointFile = {
    __typename?: 'AgentCheckpointFile';
    /** Exact UTF-8 byte length. */
    byteLength: Scalars['Int']['output'];
    /** Exact file content digest. */
    contentHash: Scalars['String']['output'];
    /** Bounded project-relative path. */
    path: Scalars['String']['output'];
    /** SERVER or CLIENT target. */
    target: Scalars['String']['output'];
};
/** Result of attaching a fresh interactive client epoch. */
export type AgentClientAttachment = {
    __typename?: 'AgentClientAttachment';
    /** New server-issued monotonic client epoch. */
    clientEpoch: Scalars['BigInt']['output'];
    /** Persisted contiguous cursor for this client instance; subscribe after this sequence. */
    replayAfterSeq: Scalars['BigInt']['output'];
    /** Session after fencing older epochs. */
    session: AgentSession;
};
/** Stable safe error envelope carried inside tool/run events. Branch on code, never message. */
export type AgentError = {
    __typename?: 'AgentError';
    /** Stable additive error code. */
    code: Scalars['String']['output'];
    /** Optional invalid input field path. */
    field: Maybe<Scalars['String']['output']>;
    /** Safe bounded human-readable detail. */
    message: Scalars['String']['output'];
    /** Optional safe human remediation, never a command to execute. */
    remediation: Maybe<Scalars['String']['output']>;
    /** Optional missing agent scope. */
    requiredScope: Maybe<Scalars['String']['output']>;
    /** Whether policy permits a deliberate retry. */
    retryable: Scalars['Boolean']['output'];
};
/** Monotonic event acknowledgement result. */
export type AgentEventAcknowledgement = {
    __typename?: 'AgentEventAcknowledgement';
    /** Highest persisted contiguous acknowledged sequence. */
    throughSeq: Scalars['BigInt']['output'];
};
/** Common identity/order fields on every typed durable agent event variant. */
export type AgentEventBase = {
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Bounded ordered history connection, exclusive of the supplied afterSeq. */
export type AgentEventConnection = {
    __typename?: 'AgentEventConnection';
    /** Events in ascending contiguous sequence order. */
    edges: Array<AgentEventEdge>;
    /** SDK-compatible ordered typed events. */
    events: Array<CrowdyStudioAgentEvent>;
    /** SDK-compatible history continuation indicator. */
    hasMore: Scalars['Boolean']['output'];
    /** History page metadata. */
    pageInfo: AgentPageInfo;
};
/** One ordered event connection edge. */
export type AgentEventEdge = {
    __typename?: 'AgentEventEdge';
    /** Opaque cursor equal to the event decimal sequence. */
    cursor: Scalars['String']['output'];
    /** Typed durable event node. */
    node: CrowdyStudioAgentEvent;
};
/** Server acknowledgement of the 2-second client heartbeat and 5-second Play freshness window. */
export type AgentHeartbeat = {
    __typename?: 'AgentHeartbeat';
    /** Play lease remains server-fresh through this instant, bounded by its hard expiry; null without an active Play lease. */
    playLeaseFreshUntil: Maybe<Scalars['DateTime']['output']>;
    /** Authoritative server receipt time. */
    serverTime: Scalars['DateTime']['output'];
    /** Renewed 30-second workspace lease expiry; null when no unchanged connected workspace lease can be renewed. */
    workspaceLeaseExpiresAt: Maybe<Scalars['DateTime']['output']>;
};
/** Two-second attached-client heartbeat that rechecks policy/permission/context, refreshes five-second Play freshness, and renews an unchanged workspace lease to 30 seconds. */
export type AgentHeartbeatInput = {
    /** Exact current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
};
/** Short-lived context-bound capability. The model cannot create, widen, or renew it. */
export type AgentLease = {
    __typename?: 'AgentLease';
    /** Bound attached browser epoch. */
    clientEpoch: Scalars['BigInt']['output'];
    /** Authoritative context version bound to the lease. */
    contextVersion: Scalars['String']['output'];
    /** Controlled entity for PLAY, or null. */
    controlledEntityId: Maybe<Scalars['String']['output']>;
    /** Expected project revision for WORKSPACE, or null. */
    expectedProjectRevision: Maybe<Scalars['BigInt']['output']>;
    /** Hard expiry; the model cannot renew it. */
    expiresAt: Scalars['DateTime']['output'];
    /** Lease grant timestamp. */
    grantedAt: Scalars['DateTime']['output'];
    /** Human-visible lease holder alias. */
    holder: Scalars['String']['output'];
    /** Host capability revision for PLAY, or null. */
    hostCapabilityRevision: Maybe<Scalars['String']['output']>;
    /** WORKSPACE or PLAY. */
    kind: CrowdyStudioAgentLeaseType;
    /** Stable lease UUID. */
    leaseId: Scalars['String']['output'];
    /** Stable revoke/expiry reason, or null while active. */
    revokedReason: Maybe<Scalars['String']['output']>;
    /** Explicit maximum scopes carried by this lease. */
    scopes: Array<Scalars['String']['output']>;
    /** Required lease lifecycle status. */
    status: CrowdyStudioAgentLeaseStatus;
};
/** Typed workspace/Play lease lifecycle event. */
export type AgentLeaseEvent = AgentEventBase & {
    __typename?: 'AgentLeaseEvent';
    /** Bound attached client epoch. */
    clientEpoch: Scalars['BigInt']['output'];
    /** Authoritative context version bound to this lease. */
    contextVersion: Scalars['String']['output'];
    /** Controlled entity identifier for PLAY, or null. */
    controlledEntityId: Maybe<Scalars['String']['output']>;
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Expected project revision for WORKSPACE, or null. */
    expectedProjectRevision: Maybe<Scalars['BigInt']['output']>;
    /** Hard lease expiry. */
    expiresAt: Scalars['DateTime']['output'];
    /** Lease grant timestamp. */
    grantedAt: Scalars['DateTime']['output'];
    /** Human-visible lease holder alias. */
    holder: Scalars['String']['output'];
    /** Host capability revision for PLAY, or null. */
    hostCapabilityRevision: Maybe<Scalars['String']['output']>;
    /** WORKSPACE or PLAY. */
    kind: CrowdyStudioAgentLeaseType;
    /** Stable lease UUID. */
    leaseId: Scalars['String']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Stable revoke/expiry reason, or null. */
    reason: Maybe<Scalars['String']['output']>;
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Explicit scopes carried when granted; empty otherwise. */
    scopes: Array<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Required lease lifecycle status. */
    status: CrowdyStudioAgentLeaseStatus;
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Typed session/client/mode/context lifecycle event. */
export type AgentLifecycleEvent = AgentEventBase & {
    __typename?: 'AgentLifecycleEvent';
    /** Attached client epoch when this event carries one. */
    clientEpoch: Maybe<Scalars['BigInt']['output']>;
    /** New context version when carried by this event. */
    contextVersion: Maybe<Scalars['String']['output']>;
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Selected mode when this event carries one. */
    mode: Maybe<CrowdyStudioAgentMode>;
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Stable lifecycle/preemption reason, or null. */
    reason: Maybe<Scalars['String']['output']>;
    /** Replay cursor returned by attach, or null. */
    replayAfterSeq: Maybe<Scalars['BigInt']['output']>;
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Typed bounded user or assistant text event. */
export type AgentMessageEvent = AgentEventBase & {
    __typename?: 'AgentMessageEvent';
    /** Redacted bounded text. ASSISTANT_MESSAGE is canonical; chunks are transient presentation hints. */
    content: Scalars['String']['output'];
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Stable message UUID used for replay deduplication. */
    messageId: Scalars['String']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** USER or ASSISTANT message role. */
    role: Scalars['String']['output'];
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Standard opaque-cursor pagination metadata. */
export type AgentPageInfo = {
    __typename?: 'AgentPageInfo';
    /** Opaque cursor for the final returned edge, or null. */
    endCursor: Maybe<Scalars['String']['output']>;
    /** Whether another page exists after endCursor. */
    hasNextPage: Scalars['Boolean']['output'];
};
/** Summary of one durable session run. */
export type AgentRun = {
    __typename?: 'AgentRun';
    /** True when the durable run status is CANCELLED. */
    cancelled: Scalars['Boolean']['output'];
    /** Run acceptance timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable terminal error code, or null while non-terminal/successful. */
    errorCode: Maybe<Scalars['String']['output']>;
    /** Terminal timestamp, or null while active. */
    finishedAt: Maybe<Scalars['DateTime']['output']>;
    /** Provider rounds already attempted in this run. */
    providerRounds: Scalars['Int']['output'];
    /** SDK-compatible terminal/preemption reason, or null. */
    reason: Maybe<Scalars['String']['output']>;
    /** Stable run UUID. */
    runId: Scalars['String']['output'];
    /** Worker start timestamp, or null while queued. */
    startedAt: Maybe<Scalars['DateTime']['output']>;
    /** Current serialized state. */
    status: CrowdyStudioAgentRunStatus;
    /** Stable preemption/cancellation reason, or null. */
    terminalReason: Maybe<Scalars['String']['output']>;
    /** Descriptor-pinned tool calls already recorded. */
    toolCalls: Scalars['Int']['output'];
};
/** Typed run lifecycle event. */
export type AgentRunEvent = AgentEventBase & {
    __typename?: 'AgentRunEvent';
    /** Stable terminal error code, or null. */
    code: Maybe<Scalars['String']['output']>;
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Safe typed error envelope when present. */
    error: Maybe<AgentError>;
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Stable terminal/preemption reason, or null. */
    reason: Maybe<Scalars['String']['output']>;
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Required durable run status carried by this event. */
    status: CrowdyStudioAgentRunStatus;
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Owner/app-scoped durable agent conversation with pinned mode, model, policy, registry, and client epoch. */
export type AgentSession = {
    __typename?: 'AgentSession';
    /** Current unexpired leases; bounded to WORKSPACE and PLAY. */
    activeLeases: Array<AgentLease>;
    /** Current non-terminal run, or null. */
    activeRun: Maybe<AgentRun>;
    /** App tenant from the app-scoped bearer token. */
    appId: Scalars['BigInt']['output'];
    /** Opaque management app-policy version pinned at creation. */
    appPolicyVersion: Scalars['String']['output'];
    /** SDK-compatible attached client epoch, or null before attach. */
    clientEpoch: Maybe<Scalars['BigInt']['output']>;
    /** Close timestamp, or null while open. */
    closedAt: Maybe<Scalars['DateTime']['output']>;
    /** Current authoritative context version. */
    contextVersion: Scalars['String']['output'];
    /** Session contract version; always 'crowdy.studio-agent/1'. */
    contractVersion: Scalars['String']['output'];
    /** Session creation timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Monotonic attached client epoch. A newer attach fences all older tabs. */
    currentClientEpoch: Scalars['BigInt']['output'];
    /** SDK-compatible current non-terminal run, or null. */
    currentRun: Maybe<AgentRun>;
    /** Selected grid id, or null; it does not grant authority. */
    gridId: Maybe<Scalars['BigInt']['output']>;
    /** Highest committed durable event sequence. */
    lastEventSeq: Scalars['BigInt']['output'];
    /** Human-selected current mode. */
    mode: CrowdyStudioAgentMode;
    /** Selected allowlisted model, matching the SDK session model. */
    model: Maybe<Scalars['String']['output']>;
    /** Newest unexpired pending approval, or null. */
    pendingApproval: Maybe<AgentApproval>;
    /** Selected private project UUID, or null. Returned only to its exact owner/app. */
    projectId: Maybe<Scalars['String']['output']>;
    /** Whether the human accepted first-use disclosure of selected private project source. Messages and metadata do not imply this consent. */
    providerDataConsent: Scalars['Boolean']['output'];
    /** Opaque platform provider-policy version pinned at creation. */
    providerPolicyVersion: Scalars['String']['output'];
    /** Digest of the mode/policy-filtered immutable tool registry. */
    registryDigest: Scalars['String']['output'];
    /** Requested model in the effective platform/app allowlist. */
    requestedModel: Scalars['String']['output'];
    /** Resolved routed model after a provider response, or null. */
    resolvedModel: Maybe<Scalars['String']['output']>;
    /** Stable session UUID. */
    sessionId: Scalars['String']['output'];
    /** Current durable session lifecycle. */
    status: CrowdyStudioAgentSessionStatus;
    /** Latest durable session update. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Bounded owner/app session connection. */
export type AgentSessionConnection = {
    __typename?: 'AgentSessionConnection';
    /** Sessions ordered newest first. */
    edges: Array<AgentSessionEdge>;
    /** SDK-compatible final opaque cursor. */
    endCursor: Maybe<Scalars['String']['output']>;
    /** SDK-compatible next-page indicator. */
    hasNextPage: Scalars['Boolean']['output'];
    /** SDK-compatible session nodes in newest-first order. */
    nodes: Array<AgentSession>;
    /** Connection page metadata. */
    pageInfo: AgentPageInfo;
};
/** Common human session-control shape for pause, resume, and close. */
export type AgentSessionControlInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
};
/** One session connection edge. */
export type AgentSessionEdge = {
    __typename?: 'AgentSessionEdge';
    /** Opaque cursor for this session edge. */
    cursor: Scalars['String']['output'];
    /** Owner/app-scoped session node. */
    node: AgentSession;
};
/** Typed browser tool-call terminal record returned after submit. */
export type AgentToolCall = {
    __typename?: 'AgentToolCall';
    /** True when the idempotent terminal result was accepted. */
    accepted: Scalars['Boolean']['output'];
    /** Canonical argument hash. */
    argumentHash: Scalars['String']['output'];
    /** Safe terminal error, or null. */
    error: Maybe<AgentError>;
    /** Durable terminal/current status. */
    status: CrowdyStudioAgentToolCallStatus;
    /** Stable tool call UUID. */
    toolCallId: Scalars['String']['output'];
    /** Logical descriptor name. */
    toolName: Scalars['String']['output'];
};
/** One effective immutable tool descriptor. Schemas are JSON Schema 2020-12 objects serialized as canonical JSON. */
export type AgentToolDescriptor = {
    __typename?: 'AgentToolDescriptor';
    /** Maximum approval lifetime in seconds. */
    approvalMaxTtlSeconds: Scalars['Int']['output'];
    /** NONE, REQUIRED, or CONDITIONAL approval policy. */
    approvalPolicy: Scalars['String']['output'];
    /** Server-authored approval reasons. */
    approvalReasons: Array<Scalars['String']['output']>;
    /** Whether exact human approval is always required. */
    approvalRequired: Scalars['Boolean']['output'];
    /** sha256 digest of the immutable descriptor contract. */
    descriptorDigest: Scalars['String']['output'];
    /** Complete RFC8785-canonical crowdy.agent-tool/1 descriptor JSON. */
    descriptorJson: Scalars['String']['output'];
    /** SERVER or BROWSER. */
    executor: CrowdyStudioAgentToolExecutor;
    /** PURE, KEYED, TOOL_CALL_ONCE, or NON_RETRYABLE. */
    idempotencyClass: Scalars['String']['output'];
    /** NONE, TOOL_CALL, or USER_TOOL_ARGUMENTS key scope. */
    idempotencyKeyScope: Scalars['String']['output'];
    /** Canonical JSON array of input redaction rules. */
    inputRedactionJson: Scalars['String']['output'];
    /** Canonical bounded input JSON Schema. */
    inputSchemaJson: Scalars['String']['output'];
    /** Maximum persisted redacted tool bytes. */
    maxPersistedBytes: Scalars['Int']['output'];
    /** Human modes in which this descriptor may be proposed. */
    modes: Array<CrowdyStudioAgentMode>;
    /** Logical dotted tool name. */
    name: Scalars['String']['output'];
    /** Canonical JSON array of output redaction rules. */
    outputRedactionJson: Scalars['String']['output'];
    /** Canonical bounded output JSON Schema. */
    outputSchemaJson: Scalars['String']['output'];
    /** Server-classified risk. */
    risk: CrowdyStudioAgentToolRisk;
    /** Canonical server-classified effect labels. */
    riskEffects: Array<Scalars['String']['output']>;
    /** Whether the classified effect is reversible. */
    riskReversible: Scalars['Boolean']['output'];
    /** Descriptor schema version; always 'crowdy.agent-tool/1'. */
    schemaVersion: Scalars['String']['output'];
    /** Canonical JSON array of complete scope requirement objects, including argument-path conditions. */
    scopeRequirementsJson: Scalars['String']['output'];
    /** Required agent scopes; ordinary platform checks still apply. */
    scopes: Array<Scalars['String']['output']>;
    /** Safe model/user-facing summary. */
    summary: Scalars['String']['output'];
    /** Hard tool execution timeout in milliseconds. */
    timeoutMs: Scalars['Int']['output'];
    /** Semantic descriptor version. */
    version: Scalars['String']['output'];
    /** Provider-safe exact wire name including major version. */
    wireName: Scalars['String']['output'];
};
/** Effective mode/policy-filtered descriptor registry. */
export type AgentToolDescriptorSet = {
    __typename?: 'AgentToolDescriptorSet';
    /** Digest pinned by the current session. */
    registryDigest: Scalars['String']['output'];
    /** Only tools implemented and currently allowed for this session; omitted contract tools are not executable. */
    tools: Array<AgentToolDescriptor>;
};
/** Typed tool event. JSON fields are descriptor-versioned and validated against the descriptor returned by crowdyStudioAgentToolDescriptors; they are never arbitrary executor input. */
export type AgentToolEvent = AgentEventBase & {
    __typename?: 'AgentToolEvent';
    /** Opaque approval capability, or null. */
    approvalGrant: Maybe<Scalars['String']['output']>;
    /** Canonical argument hash, or null. */
    argumentHash: Maybe<Scalars['String']['output']>;
    /** Descriptor-schema-validated, redaction-safe canonical JSON arguments for browser dispatch; null otherwise. */
    argumentsJson: Maybe<Scalars['String']['output']>;
    /** Fenced browser epoch for a dispatch, or null. */
    clientEpoch: Maybe<Scalars['BigInt']['output']>;
    /** Authoritative dispatch context version, or null. */
    contextVersion: Maybe<Scalars['String']['output']>;
    /** Commit timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Dispatch deadline, or null for non-dispatch events. */
    deadline: Maybe<Scalars['DateTime']['output']>;
    /** Pinned descriptor digest, or null before dispatch. */
    descriptorDigest: Maybe<Scalars['String']['output']>;
    /** Safe typed terminal tool error, or null. */
    error: Maybe<AgentError>;
    /** Stable event UUID for deduplication. */
    eventId: Scalars['String']['output'];
    /** SERVER or BROWSER executor, or null. */
    executor: Maybe<CrowdyStudioAgentToolExecutor>;
    /** Executor idempotency key, or null. */
    idempotencyKey: Maybe<Scalars['String']['output']>;
    /** Complete browser invocation on TOOL_DISPATCHED; null for other events. */
    invocation: Maybe<AgentToolInvocation>;
    /** Bound lease UUID, or null. */
    leaseId: Maybe<Scalars['String']['output']>;
    /** Event envelope version; always 'crowdy.agent-event/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Complete typed terminal result when available. */
    result: Maybe<AgentToolResultEnvelope>;
    /** Descriptor-schema-validated, redaction-safe canonical JSON result summary; source and prompt bodies are omitted. */
    resultJson: Maybe<Scalars['String']['output']>;
    /** Related run UUID, or null for session-only facts. */
    runId: Maybe<Scalars['String']['output']>;
    /** Safe bounded human summary, or null. */
    safeSummary: Maybe<Scalars['String']['output']>;
    /** Strictly increasing session sequence as a decimal BigInt. */
    seq: Scalars['BigInt']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Required durable tool status for this event. */
    status: CrowdyStudioAgentToolCallStatus;
    /** Stable tool call UUID. */
    toolCallId: Scalars['String']['output'];
    /** Logical versioned tool name. */
    toolName: Scalars['String']['output'];
    /** Pinned semantic tool version. */
    toolVersion: Scalars['String']['output'];
    /** Stable version 1 event discriminator. */
    type: CrowdyStudioAgentEventType;
    /** Versioned event payload contract. */
    version: Scalars['String']['output'];
};
/** Complete crowdy.tool-call/1 browser invocation envelope. Arguments are canonical descriptor-validated JSON. */
export type AgentToolInvocation = {
    __typename?: 'AgentToolInvocation';
    /** Opaque consumed approval capability when required. */
    approvalGrant: Maybe<Scalars['String']['output']>;
    /** Canonical argument/context hash. */
    argumentHash: Scalars['String']['output'];
    /** Canonical JSON object matching the descriptor input schema. */
    argumentsJson: Scalars['String']['output'];
    /** Required matching browser epoch. */
    clientEpoch: Maybe<Scalars['BigInt']['output']>;
    /** Authoritative context version. */
    contextVersion: Scalars['String']['output'];
    /** Hard browser execution deadline. */
    deadline: Scalars['DateTime']['output'];
    /** Pinned canonical descriptor digest. */
    descriptorDigest: Scalars['String']['output'];
    /** Server-issued executor idempotency key when required. */
    idempotencyKey: Maybe<Scalars['String']['output']>;
    /** Required lease UUID when the tool scopes demand one. */
    leaseId: Maybe<Scalars['String']['output']>;
    /** Logical tool name. */
    name: Scalars['String']['output'];
    /** Invocation version; always 'crowdy.tool-call/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Owning run UUID. */
    runId: Scalars['String']['output'];
    /** Owning session UUID. */
    sessionId: Scalars['String']['output'];
    /** Execute-once tool call UUID. */
    toolCallId: Scalars['String']['output'];
    /** Pinned semantic tool version. */
    version: Scalars['String']['output'];
};
/** Complete crowdy.tool-result/1 terminal browser result with exact timing and safe typed error. */
export type AgentToolResultEnvelope = {
    __typename?: 'AgentToolResultEnvelope';
    /** Safe typed error for non-success, or null. */
    error: Maybe<AgentError>;
    /** Browser execution finish timestamp. */
    finishedAt: Scalars['DateTime']['output'];
    /** Context version observed by the browser executor. */
    observedContextVersion: Scalars['String']['output'];
    /** Canonical descriptor-validated output JSON, or null. */
    outputJson: Maybe<Scalars['String']['output']>;
    /** Result version; always 'crowdy.tool-result/1'. */
    protocolVersion: Scalars['String']['output'];
    /** Browser execution start timestamp. */
    startedAt: Scalars['DateTime']['output'];
    /** Terminal result status. */
    status: CrowdyStudioAgentToolResultStatus;
    /** Matching tool call UUID. */
    toolCallId: Scalars['String']['output'];
};
/** Complete crowdy.tool-result/1 browser result envelope. */
export type AgentToolResultEnvelopeInput = {
    /** Stable AGENT_* error code for non-success; omit for SUCCEEDED. */
    errorCode?: InputMaybe<Scalars['String']['input']>;
    /** Safe bounded error message for non-success; no stack, source, prompt, headers, or tokens. */
    errorMessage?: InputMaybe<Scalars['String']['input']>;
    /** Whether policy permits deliberate retry; defaults false. */
    errorRetryable?: InputMaybe<Scalars['Boolean']['input']>;
    /** Browser execution finish timestamp. */
    finishedAt: Scalars['DateTime']['input'];
    /** Exact authoritative context version observed by the host. */
    observedContextVersion: Scalars['String']['input'];
    /** Output JSON object required for SUCCEEDED and validated against the pinned descriptor; omit for failures. Maximum 128 KiB. */
    outputJson?: InputMaybe<Scalars['String']['input']>;
    /** Result protocol version; must be 'crowdy.tool-result/1'. */
    protocolVersion: Scalars['String']['input'];
    /** Browser execution start timestamp. */
    startedAt: Scalars['DateTime']['input'];
    /** Known terminal executor outcome. */
    status: CrowdyStudioAgentToolResultStatus;
    /** Dispatched tool call UUID. */
    toolCallId: Scalars['String']['input'];
};
/** Submit one idempotent terminal browser result for the matching owner/session epoch. */
export type AgentToolResultInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Complete descriptor-validated crowdy.tool-result/1 result envelope. */
    result: AgentToolResultEnvelopeInput;
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
};
/** A publishable application (game/experience) owned by an organization. Its discoverability is controlled by visibility and its lifecycle by status. */
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'];
    /** Player-code censorship mode: "implicit_allow" (default/off) or "allow_list" (strict admission of every running artifact, including self-authored code). */
    codeAdmissionMode: Scalars['String']['output'];
    /** Timestamp when the app was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Numeric user id of the account that created the app. */
    createdBy: Scalars['BigInt']['output'];
    /** Where the app runs: "none" (draft / not deployed), "shared" (the shared game-api), or "dedicated" (a provisioned per-tenant environment). */
    deploymentTarget: Scalars['String']['output'];
    /** Short plain-text description shown in listings; also matched by the marketplace free-text filter. */
    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']>;
    /** Player user ids allowed to approve grid claim requests in "approval" mode. When empty, approval falls back to org staff holding manage_compute. */
    gridClaimApproverUserIds: Array<Scalars['String']['output']>;
    /** How a player claim confers grid ownership (D4): "self_claim" (the claim right alone; default), "approval" (designated approvers accept claim requests), "invite" (standing invites only), or "marketplace_only" (only a marketplace grid purchase; the purchase edge ships in P4b). */
    gridClaimPolicy: 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. */
    name: Scalars['String']['output'];
    /** The organization that owns this app. Null if the owning org cannot be found. */
    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". */
    runtimeStatus: Scalars['String']['output'];
    /** URL-safe slug, unique within the org; combined with the org slug to form the marketplace path. May be null for legacy rows. */
    slug: Maybe<Scalars['String']['output']>;
    /** True when this app's runtime data lives in a dedicated per-tenant game-api database (rather than the shared game-api). Used together with gameApiUrl to route gameplay calls. */
    splitMode: Scalars['Boolean']['output'];
    /** Base64-encoded binary blob of the app's persisted runtime/world state; opaque to clients and potentially large. Null when no state has been saved. */
    state: Maybe<Scalars['String']['output']>;
    /** Lifecycle state (DRAFT/LIVE/ARCHIVED). See AppStatus. */
    status: AppStatus;
    /** Timestamp when the app was last updated. */
    updatedAt: Scalars['DateTime']['output'];
    /** Marketplace discoverability (PUBLIC/UNLISTED/PRIVATE). See AppVisibility. */
    visibility: AppVisibility;
};
/** A free or purchasable access tier for an app, bundling a price and the set of runtime permission keys that granted users receive. */
export type AppAccessTier = {
    __typename?: 'AppAccessTier';
    /** Numeric id of the app this tier belongs to. */
    appId: Scalars['BigInt']['output'];
    /** Billing cadence for recurring tiers (e.g. "month", "year"); null for one-time or free tiers. */
    billingPeriod: Maybe<Scalars['String']['output']>;
    /** Timestamp when the tier was created. */
    createdAt: Scalars['DateTime']['output'];
    /** ISO 4217 currency code for priceCents (e.g. "usd"); defaults to "usd". */
    currency: Maybe<Scalars['String']['output']>;
    /** Optional marketing description of what the tier includes. */
    description: Maybe<Scalars['String']['output']>;
    /** True if this is the app default tier (used for open-by-default / self-service grants). At most one default per app is expected. */
    isDefault: Scalars['Boolean']['output'];
    /** True if the tier has no purchase cost. */
    isFree: Scalars['Boolean']['output'];
    /** Display name of the tier (e.g. "Free", "Pro"). */
    name: Scalars['String']['output'];
    /** Runtime permission keys granted to users on this tier (a subset of runtimePermissions), e.g. "access", "teleport", "update_voxel_data", "use_voice_chat". */
    permissionKeys: Array<Scalars['String']['output']>;
    /** Price in the smallest currency unit (cents) for paid tiers; null for free tiers. */
    priceCents: Maybe<Scalars['BigInt']['output']>;
    /** Tier lifecycle: "active" or "archived" (soft-deleted via archiveAccessTier). Defaults to "active". */
    status: Scalars['String']['output'];
    /** Unique numeric id of the tier (primary key). */
    tierId: Scalars['BigInt']['output'];
    /** Sort order for displaying tiers (ascending); lower values appear first. */
    tierOrder: Scalars['Float']['output'];
    /** 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. */
    appId: Scalars['BigInt']['output'];
    /** Avatar id this state belongs to. BigInt serialized as a decimal string. */
    avatarId: Scalars['BigInt']['output'];
    /** Row creation timestamp (ISO-8601). */
    createdAt: Scalars['DateTime']['output'];
    /** Per-app avatar state blob, base64-encoded binary; null when cleared. Owner-exclusive write, public read. */
    state: Maybe<Scalars['String']['output']>;
    /** Last-update timestamp (ISO-8601). */
    updatedAt: Scalars['DateTime']['output'];
};
export type AppBudget = {
    __typename?: 'AppBudget';
    /** Unique app-budget id (BigInt as a decimal string). */
    appBudgetId: Scalars['BigInt']['output'];
    /** App this budget applies to (BigInt as a decimal string). */
    appId: Scalars['BigInt']['output'];
    /** When the budget was first created (ISO-8601 UTC timestamp). */
    createdAt: Scalars['DateTime']['output'];
    /** Spend so far in the current monthly period, in minor currency units (cents) as a BigInt decimal string. Resets when `periodStart` rolls over to a new month. */
    currentMonthUsageCents: Scalars['BigInt']['output'];
    /** Monthly spend cap in minor currency units (cents) as a BigInt decimal string; null means no cap is configured (unlimited). */
    monthlyLimitCents: Maybe<Scalars['BigInt']['output']>;
    /** Organization that owns the app (BigInt as a decimal string). */
    orgId: Scalars['BigInt']['output'];
    /** Start of the current monthly budget period (ISO-8601 UTC timestamp), truncated to the first day of the month. */
    periodStart: Scalars['DateTime']['output'];
    /** When the budget was last updated (ISO-8601 UTC timestamp). */
    updatedAt: Scalars['DateTime']['output'];
};
/** An active or revoked app code-admission entry. Admission controls execution only; it never grants source access. */
export type AppCodeAdmission = {
    __typename?: 'AppCodeAdmission';
    /** UUID of this admission record. */
    admissionId: Scalars['String']['output'];
    /** When the entry was admitted. */
    admittedAt: Scalars['DateTime']['output'];
    /** Numeric user id of the org member who admitted the subject. */
    admittedBy: Scalars['BigInt']['output'];
    /** Numeric app id whose code-admission policy owns this entry. */
    appId: Scalars['BigInt']['output'];
    /** When the entry was revoked; null while active. */
    revokedAt: Maybe<Scalars['DateTime']['output']>;
    /** Whether this entry admits code, an author, or an org. */
    subjectKind: CodeAdmissionSubjectKind;
    /** Stable id of the admitted subject (listing UUID, user id, or org id). */
    subjectRef: Scalars['String']['output'];
    /** Optional P1 version range: exact "3", inclusive "2-5", ">=4", or "<=9". Null admits all versions; invalid expressions fail closed at runtime. */
    versionRange: Maybe<Scalars['String']['output']>;
};
/** An app's compute allowance in units per minute, spanning the expression engine and both WASM tiers. Absent when no allowance has been set for the app, in which case the app is measured against the platform reference allowance and is never refused. */
export type AppComputeBudgetInfo = {
    __typename?: 'AppComputeBudgetInfo';
    /** The app the allowance belongs to. */
    appId: Scalars['BigInt']['output'];
    /** When false the allowance is observed and recorded and nothing is refused (the ship default). When true, exceeding it refuses further model invokes until the minute rolls. Enforcement additionally requires the fleet kill switch to be in its default position, so a true here can still be observing. */
    enforce: Scalars['Boolean']['output'];
    /** Why this number was chosen. Recorded because an allowance with no stated basis is a number the next operator cannot safely change. */
    note: Maybe<Scalars['String']['output']>;
    /** Compute units this app may consume per minute. */
    unitsPerMinute: Scalars['BigInt']['output'];
    /** When the allowance was last written. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Whether an app is inside its per-minute compute allowance right now, and what would happen if it were not. Reading this does not charge anything. */
export type AppComputeBudgetStatus = {
    __typename?: 'AppComputeBudgetStatus';
    /** The allowance the decision was made against. */
    allowance: Scalars['BigInt']['output'];
    /** True when the allowance is the app's own stored one, false when it is the platform reference allowance. The reference allowance can never refuse — it exists so shadow-mode observations have a denominator. */
    allowanceIsAppOwn: Scalars['Boolean']['output'];
    /** The app. */
    appId: Scalars['BigInt']['output'];
    /** Which engines the units came from. Carried on every decision because a single allowance spans the engines, so a player invoke can be refused for compute modules the developer forgot were ticking — and that is only explainable with the breakdown. */
    byEngine: Array<EngineComputeUnits>;
    /** Whether being over the allowance is currently refusing invokes. False while in shadow mode, which is the ship default. */
    enforced: Scalars['Boolean']['output'];
    /** Whether the app is over the allowance this minute. */
    overBudget: Scalars['Boolean']['output'];
    /** Milliseconds until the minute rolls and the allowance resets. */
    retryAfterMs: Scalars['Int']['output'];
    /** Compute units accrued in the current minute, across every engine. Between reconciles this is the serving instance's own view, so it can read low on a multi-instance fleet; it converges within seconds. */
    unitsUsed: Scalars['BigInt']['output'];
};
/** What an app consumed, per engine, in ONE unit — the number a developer uses to compare the model engine against compute modules, and the number an operator's per-minute allowance is checked against. Derived from the existing per-minute ledgers (wasm_compute_usage, player_wasm_compute_usage, gm_automation_runs, gm_event_log); there is deliberately no separate rollup table for it. */
export type AppComputeUsage = {
    __typename?: 'AppComputeUsage';
    /** Units per engine, always including engines that contributed nothing, so a zero is distinguishable from an engine the query forgot. */
    byEngine: Array<EngineComputeUnits>;
    /** Units divided by the window length. Useful for cost, misleading for safety — compare peakMinuteUnits against an allowance, not this. */
    meanUnitsPerMinute: Scalars['Float']['output'];
    /** The highest single minute in the window, summed across engines. This is the number a per-minute allowance refuses on: a mean over an hour hides the minute that would have been refused. */
    peakMinuteUnits: Scalars['BigInt']['output'];
    /** Compute units across every engine in the window. */
    totalUnits: Scalars['BigInt']['output'];
    /** Length of the window in minutes, as clamped (1 to 1440). */
    windowMinutes: Scalars['Int']['output'];
};
/** Where an app runs: none (draft), shared (the shared game-api), or dedicated (a provisioned environment). */
export declare enum AppDeploymentTarget {
    /** Runs on a dedicated, org-provisioned environment. */
    Dedicated = "DEDICATED",
    /** Draft / unpublished: the app is not deployed to any runtime. */
    None = "NONE",
    /** Runs on the multi-tenant shared game-api (publishAppToShared). */
    Shared = "SHARED"
}
/** Where one app lives, and therefore which origin a client should talk to before it does anything else. Public: this is the same information the published DNS names already expose. */
export type AppDiscovery = {
    __typename?: 'AppDiscovery';
    /** The app this entry describes, echoed back so a batched result can be matched to its request. */
    appId: Scalars['BigInt']['output'];
    /** Datacenter code the app is placed in (for example `or`, `va`), or null if the app has no placement yet. */
    datacenterCode: Maybe<Scalars['String']['output']>;
    /** HTTPS GraphQL origin for this app's OWN datacenter. Move here BEFORE authenticating: logging in through the shared origin writes the session on whichever datacenter DNS happened to pick, and the app token then has to be minted across a WAN. Null when the app has no placement, in which case keep using the shared origin. */
    gameApiUrl: Maybe<Scalars['String']['output']>;
    /** The wss:// form of gameApiUrl, for the subscription socket and the binary relay. */
    gameApiWsUrl: Maybe<Scalars['String']['output']>;
};
/** An edge in a App connection. */
export type AppEdge = {
    __typename?: 'AppEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: App;
};
/** Org member eligible for app access grants. Scoped to the app org; requires manage_access_tiers. */
export type AppGrantMemberCandidate = {
    __typename?: 'AppGrantMemberCandidate';
    /** Email of the candidate, if known. */
    email: Maybe<Scalars['String']['output']>;
    /** Gamertag / display handle of the candidate, if set. */
    gamertag: Maybe<Scalars['String']['output']>;
    /** Numeric id of the candidate user (use with grantAppAccess). */
    userId: Scalars['BigInt']['output'];
};
/** Per-app, per-type policy controlling who may create groups of a type and the default membership policy of new groups. */
export type AppGroupPolicy = {
    __typename?: 'AppGroupPolicy';
    /** The app (tenant) the policy applies to. */
    appId: Scalars['BigInt']['output'];
    /** admin | member | anyone */
    creationPolicy: Scalars['String']['output'];
    /** open | request | invite | admin */
    defaultMembershipPolicy: Scalars['String']['output'];
    /** The group type the policy governs: 'team' | 'channel' | 'grid'. */
    groupType: Scalars['String']['output'];
    /** Optional cap on groups of this type a user may belong to (null = unlimited). */
    maxGroupsPerUser: Maybe<Scalars['Int']['output']>;
    /** Optional cap on members per group (null = unlimited). */
    maxMembers: Maybe<Scalars['Int']['output']>;
};
/** Optional filters for the public marketplace apps listing. */
export type AppMarketplaceFilterInput = {
    /** Restrict results to a single organization by its slug (storefront view). Omit to search across all orgs. */
    orgSlug?: InputMaybe<Scalars['String']['input']>;
    /** Free-text search applied to app name and description (case-insensitive substring match). Omit for no text filter. */
    query?: InputMaybe<Scalars['String']['input']>;
};
/** Per-player usage row for studio diagnostics (top spenders / quota utilization): one (player, app) aggregate over a window. */
export type AppPlayerUsageRow = {
    __typename?: 'AppPlayerUsageRow';
    /** Player automation units used. */
    automationUnits: Scalars['BigInt']['output'];
    /** Cents charged in the window. */
    chargedCents: Scalars['BigInt']['output'];
    /** Compile submissions. */
    compileCount: Scalars['Int']['output'];
    /** Player compute units used. */
    computeUnits: Scalars['BigInt']['output'];
    /** The player (grid owner). */
    userId: Scalars['BigInt']['output'];
};
/** The shared-environment runtime gate + current billing-window usage for an app. */
export type AppRuntimeState = {
    __typename?: 'AppRuntimeState';
    /** App id (BigInt). */
    appId: Scalars['BigInt']['output'];
    /** Spend so far in the current day window, in cents. */
    currentDayUsageCents: Scalars['BigInt']['output'];
    /** Spend so far in the current hour window, in cents. */
    currentHourUsageCents: Scalars['BigInt']['output'];
    /** Per-app daily spend cap in cents (set via setAppSpendCaps). Null = no cap. */
    dailyLimitCents: Maybe<Scalars['BigInt']['output']>;
    /** Where the app runs (none / shared / dedicated). */
    deploymentTarget: AppDeploymentTarget;
    /** Per-app hourly spend cap in cents (set via setAppSpendCaps). Null = no cap. */
    hourlyLimitCents: Maybe<Scalars['BigInt']['output']>;
    /** free_allowance | insufficient_funds | spend_cap | subscription_lapsed when not active. */
    runtimeDenialReason: Maybe<Scalars['String']['output']>;
    /** Current runtime gate decision (active / grace / denied / suspended). */
    runtimeStatus: AppRuntimeStatus;
    /** Owning org wallet balance, in cents. */
    walletBalanceCents: Scalars['BigInt']['output'];
};
/** The per-app runtime gate game-api + Buddy enforce. See runtimeDenialReason when not active. */
export declare enum AppRuntimeStatus {
    /** Allowed to run; clients may connect. */
    Active = "ACTIVE",
    /** Blocked from running now (e.g. insufficient funds, spend cap hit, or free allowance exhausted); recoverable once the cause clears. */
    Denied = "DENIED",
    /** Still running on a temporary allowance (e.g. low funds) but at risk of being denied soon. */
    Grace = "GRACE",
    /** Hard-stopped (e.g. lapsed subscription); requires action to restore. */
    Suspended = "SUSPENDED"
}
/** @deprecated Legacy paid shared-environment subscription for an app slot. Null when the app has none. */
export type AppSharedSubscription = {
    __typename?: 'AppSharedSubscription';
    /** App id (BigInt). */
    appId: Scalars['BigInt']['output'];
    /** End of the current paid period (when access lapses if not renewed). */
    currentPeriodEnd: Maybe<Scalars['DateTime']['output']>;
    /** Owning organization id (BigInt). */
    orgId: Scalars['BigInt']['output'];
    /** Subscribed plan id (BigInt). Null when not on a paid plan. */
    planId: Maybe<Scalars['BigInt']['output']>;
    /** Payment provider backing the subscription, e.g. 'stripe'. */
    provider: Maybe<Scalars['String']['output']>;
    /** Subscription status, e.g. 'active', 'past_due', or 'canceled'. */
    status: Scalars['String']['output'];
};
/** Lifecycle state of an app. Independent of AppVisibility; the public marketplace requires status=LIVE. */
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. 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"
}
/** A short-lived, app-scoped gameplay token (Overworld portal). Confined to a single app: usable only against that app's Game API + Buddy realtime surface (plus read-only `me` and same-app `refreshAppToken`). It CANNOT perform management operations and CANNOT mint tokens for other apps, so a game stack that receives it never gets the player's full identity session. */
export type AppTokenResponse = {
    __typename?: 'AppTokenResponse';
    /** The app this token is confined to, as a String. */
    appId: Scalars['String']['output'];
    /** Stable entry origin, resolving to every datacenter, that always reaches SOME healthy instance. Use it to re-discover endpoints when `gameApiUrl` stops answering: a token-holding client cannot re-mint, because that needs the identity session it does not have. Never a per-datacenter or per-instance address. */
    discoveryUrl: Maybe<Scalars['String']['output']>;
    /** ISO-8601 UTC expiry. Call `refreshAppToken` (same app) before this, or re-portal through the Overworld for a different app. */
    expiresAt: Scalars['String']['output'];
    /** Base HTTPS URL of the Game API that serves this app — its OWN datacenter's endpoint when a placement exists, because that is where the app's shards are. Null if the app has no dedicated/shared game-api route yet. Use this for gameplay; use `discoveryUrl` to recover if it stops answering. */
    gameApiUrl: Maybe<Scalars['String']['output']>;
    /** WebSocket URL of the Game API that serves this app (wss://), for realtime subscriptions. */
    gameApiWsUrl: Maybe<Scalars['String']['output']>;
    /** Identifier of the underlying game_token row, as a String. */
    gameTokenId: Scalars['String']['output'];
    /** Browser launch URL for this app (where the player's browser plays it), if configured. */
    launchUrl: Maybe<Scalars['String']['output']>;
    /** 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 plus the top GraphQL operations for one app over the window. */
export type AppUsageSummary = {
    __typename?: 'AppUsageSummary';
    /** App id (as a string). */
    appId: Scalars['String']['output'];
    /** Billed autonomous-process compute units over the window (string counter). */
    automationComputeUnits: Scalars['String']['output'];
    /** Autonomous-process function invocations over the window (string counter). */
    automationInvocations: Scalars['String']['output'];
    /** Autonomous-process (NPC) runs over the window (string counter). */
    automationRuns: Scalars['String']['output'];
    /** Total GraphQL bytes received (string counter). */
    graphqlRecvBytes: Scalars['String']['output'];
    /** Total GraphQL bytes sent (string counter). */
    graphqlSendBytes: Scalars['String']['output'];
    /** Total replication bytes received (string counter). */
    replicationRecvBytes: Scalars['String']['output'];
    /** Total replication bytes sent (string counter). */
    replicationSendBytes: Scalars['String']['output'];
    /** Top GraphQL operations by bytes (capped by operationLimit). */
    topGraphqlOperations: Array<GraphqlOperationUsageRow>;
};
/** A user's entitlement to a specific app: whether (and via which tier) they may access it. At most one row per (app, user). */
export type AppUserAccess = {
    __typename?: 'AppUserAccess';
    /** Numeric id of the app this access applies to. */
    appId: Scalars['BigInt']['output'];
    /** Unique numeric id of this access record (primary key). */
    appUserAccessId: Scalars['BigInt']['output'];
    /** Timestamp when the access record was first created. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional expiry timestamp; access is treated as inactive once it has passed. Null means the grant does not expire. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** Who granted this access: the granting admin's numeric user id (as a string), or "system" for automatic/free-tier grants. */
    grantedBy: Scalars['String']['output'];
    /** Entitlement lifecycle: "active" (currently entitled) or "revoked" (access removed). Only active, non-expired rows grant runtime access. Defaults to "active". */
    status: Scalars['String']['output'];
    /** External billing subscription id (e.g. Stripe/PayPal) backing a paid grant; null for free or manual grants. */
    subscriptionId: Maybe<Scalars['String']['output']>;
    /** The access tier granted by this record. Null if no tier is associated (tierId is null) or the tier could not be loaded. */
    tier: Maybe<AppAccessTier>;
    /** Numeric id of the access tier granting this access; null if access was granted without a specific tier. */
    tierId: Maybe<Scalars['BigInt']['output']>;
    /** Timestamp when the access record was last updated (e.g. re-granted or revoked). */
    updatedAt: Scalars['DateTime']['output'];
    /** The user this access record belongs to. Null if the user could not be loaded. */
    user: Maybe<User>;
    /** Numeric id of the user this access belongs to. */
    userId: Scalars['BigInt']['output'];
};
/** A Relay cursor connection over AppUserAccess records. Page with first/after; pass pageInfo.endCursor back as after for the next page. */
export type AppUserAccessConnection = {
    __typename?: 'AppUserAccessConnection';
    /** Edges on this page. */
    edges: Array<AppUserAccessEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** An edge in a AppUserAccess connection. */
export type AppUserAccessEdge = {
    __typename?: 'AppUserAccessEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: AppUserAccess;
};
/** Controls where an app can be discovered. Independent of AppStatus (the marketplace additionally requires status=LIVE). */
export declare enum AppVisibility {
    /** Hidden from the marketplace; visible only to org members and users with an access grant. */
    Private = "PRIVATE",
    /** Listed in the public marketplace (when status=LIVE) and resolvable by slug. */
    Public = "PUBLIC",
    /** Hidden from marketplace listings but accessible to anyone who knows the direct org/app slug link. */
    Unlisted = "UNLISTED"
}
/** A Relay cursor connection over App records. Page with first/after; pass pageInfo.endCursor back as after for the next page. */
export type AppsConnection = {
    __typename?: 'AppsConnection';
    /** Edges on this page. */
    edges: Array<AppEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** A paginated page of apps returned by the marketplace listing. */
export type AppsPage = {
    __typename?: 'AppsPage';
    /** The apps on this page, ordered newest-first. */
    items: Array<App>;
    /** Pagination metadata: totalCount (total matches ignoring limit/offset) plus the applied limit and offset. */
    pageInfo: PageInfo;
};
export type AssignGridOwnershipInput = {
    /** App that contains the grid. */
    appId: Scalars['BigInt']['input'];
    /** Required for RENTED tenure; omitted for permanent ownership. */
    expiresAt?: InputMaybe<Scalars['DateTime']['input']>;
    /** Grid to assign. */
    gridId: Scalars['BigInt']['input'];
    /** User id receiving title. P1 only permits user owners. */
    ownerUserId: Scalars['BigInt']['input'];
    /** OWNED (default) or RENTED. */
    tenure?: InputMaybe<GridTenure>;
};
/** Grant runtime permission keys to a group (optionally one role) on a grid (writes the grid_group_grants input table). */
export type AssignGroupToGridInput = {
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['input'];
    /** Optional expiry; after this time the grant stops contributing to the effective ACL. Null/omitted means it never expires. */
    expiresAt?: InputMaybe<Scalars['DateTime']['input']>;
    /** The grid to grant on. */
    gridId: Scalars['BigInt']['input'];
    /** The group whose members receive the grant. Must belong to the same app. */
    groupId: Scalars['BigInt']['input'];
    /** Optional: scope the grant to members holding this group role. Omit to grant to all members of the group. */
    groupRoleId?: InputMaybe<Scalars['BigInt']['input']>;
    /** 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']>;
};
/** Attach one interactive browser and optional selected project/grid, atomically repinning policy/registry/context while fencing old tabs, leases, approvals, and browser dispatches. */
export type AttachAgentClientInput = {
    /** Optional stable browser instance UUID. Omit to use the single-interactive-client session cursor. */
    clientInstanceId?: InputMaybe<Scalars['String']['input']>;
    /** Optional authoritative grid context selected by the attaching Studio. Omit to retain the current grid. */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Optional owner project UUID selected by the attaching Studio. Omit to retain the current selection; null explicitly clears it outside BUILD. */
    projectId?: InputMaybe<Scalars['String']['input']>;
    /** Owner/app session UUID. */
    sessionId: 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';
    /** Identifier of the underlying session (game_token) row, as a String. */
    gameTokenId: Scalars['String']['output'];
    /** Opaque session token. Send it on subsequent requests as the `Authorization: Bearer <token>` header. */
    token: Scalars['String']['output'];
    /** 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). */
    avatarId: Scalars['ID']['output'];
    /** Server timestamp (ISO-8601) when the avatar was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Human-readable avatar name. */
    name: Scalars['String']['output'];
    /** Owner-only private state blob, base64-encoded binary. Stripped (returned null) for non-owners (e.g. via `userAvatars`/`avatar` when the caller is not the owner). */
    privateState: Maybe<Scalars['String']['output']>;
    /** Public state blob, base64-encoded binary; visible to all viewers. */
    publicState: Maybe<Scalars['String']['output']>;
    /** Owner user id. BigInt serialized as a decimal string. NOTE: the AvatarDTO returned by `myAvatars` exposes this same value typed as a GraphQL ID instead of BigInt. */
    userId: Scalars['BigInt']['output'];
};
export type AvatarDto = {
    __typename?: 'AvatarDTO';
    /** Avatar id, serialized as a GraphQL ID (a numeric string). */
    avatarId: Scalars['ID']['output'];
    /** Server timestamp (ISO-8601) when the avatar was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Human-readable avatar name. */
    name: Scalars['String']['output'];
    /** Owner-only private state blob, base64-encoded binary. Returned by `myAvatars` (caller is the owner); stripped to null for non-owners on other queries. */
    privateState: Maybe<Scalars['String']['output']>;
    /** Public state blob, base64-encoded binary; visible to all viewers. */
    publicState: Maybe<Scalars['String']['output']>;
    /** Owner user id, serialized as a GraphQL ID (a numeric string). Same underlying value as Avatar.userId, which is typed as BigInt. */
    userId: Scalars['ID']['output'];
};
export type BatchActorLookupInput = {
    /** Actor ids to look up. Each is exactly 32 ASCII characters (the UDP-wire actor id), NOT a hyphenated RFC-4122 UUID. Must be non-empty; unknown ids are silently omitted from the result. */
    uuids: Array<Scalars['String']['input']>;
};
/** An organization whose wallet is not debited and whose apps are not denied for funds. Usage is still metered; waived amounts are in org_billing_waivers. */
export type BillingExemptOrgType = {
    __typename?: 'BillingExemptOrgType';
    /** Organization name. */
    name: Scalars['String']['output'];
    /** Organization id (BigInt as a decimal string). */
    orgId: Scalars['BigInt']['output'];
    /** Why the exemption exists. Required when setting it true. */
    reason: Scalars['String']['output'];
    /** When the exemption was last set true. */
    setAt: Scalars['DateTime']['output'];
    /** Operator user_id who last set the exemption true. */
    setBy: Maybe<Scalars['BigInt']['output']>;
    /** Organization slug. */
    slug: Scalars['String']['output'];
};
/** Live (most recent heartbeat) Buddy UDP throughput rates. */
export type BuddyLiveRates = {
    __typename?: 'BuddyLiveRates';
    /** Megabits per second received from clients. */
    clientRecvMbitPerSec: Scalars['Float']['output'];
    /** Messages per second received from clients. */
    clientRecvMsgsPerSec: Scalars['Float']['output'];
    /** Megabits per second sent to clients. */
    clientSendMbitPerSec: Scalars['Float']['output'];
    /** Messages per second sent to clients. */
    clientSendMsgsPerSec: Scalars['Float']['output'];
    /** Currently connected client count. */
    clients: Scalars['Float']['output'];
    /** Buddy/runtime server id reporting these rates. */
    serverId: Scalars['String']['output'];
    /** Timestamp of the heartbeat these rates came from. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Immediately request cancellation of one active session run. */
export type CancelAgentRunInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Active run UUID to cancel; omit to cancel the session currentRun. */
    runId?: InputMaybe<Scalars['String']['input']>;
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
};
/** Input for publishing a message to a channel. Delivered to every active member of the channel (regardless of location), not chunk-routed. The sender must have the channel send_messages permission. */
export type ChannelMessageInput = {
    /** The channel id (groups.group_id) to publish to. */
    channelId: Scalars['BigInt']['input'];
    /** The message payload, base64-encoded. Opaque to the server; decode per your application protocol. Max 1024 bytes. */
    payload: Scalars['String']['input'];
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on any GenericErrorResponse for this send, delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** The sender's actor UUID (your own actor's UUID). Must be exactly 32 bytes when encoded as UTF-8. */
    uuid: Scalars['String']['input'];
};
/** Notification received when a message is published to a channel you are a member of. Delivered over the udpNotifications subscription to every active channel member. */
export type ChannelMessageNotification = {
    __typename?: 'ChannelMessageNotification';
    /** The channel id (groups.group_id) the message was sent to. */
    channelId: Scalars['BigInt']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The message payload, base64-encoded. Opaque to the server; decode per your application protocol. */
    payload: Scalars['String']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** 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. */
    amountCents: Maybe<Scalars['BigInt']['output']>;
    /** Target app for the purpose (BigInt as a decimal string); null when not applicable. */
    appId: Maybe<Scalars['BigInt']['output']>;
    /** Unique checkout id (BigInt as a decimal string). */
    checkoutId: Scalars['BigInt']['output'];
    /** When the checkout reached COMPLETED (ISO-8601 UTC timestamp); null until then. */
    completedAt: Maybe<Scalars['DateTime']['output']>;
    /** When the checkout was created (ISO-8601 UTC timestamp). */
    createdAt: Scalars['DateTime']['output'];
    /** ISO-4217 currency code for `amountCents`, lowercase (e.g. "usd"); null when no amount applies. */
    currency: Maybe<Scalars['String']['output']>;
    /** Failure reason when `status` is FAILED; null otherwise. */
    error: Maybe<Scalars['String']['output']>;
    /** When the provider session expires if still unpaid (ISO-8601 UTC timestamp); null if there is no expiry. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** Identifier of the session/order in the provider (e.g. Stripe Checkout Session id, PayPal Order id). */
    externalId: Scalars['String']['output'];
    /** Provider-hosted URL to redirect the user to in order to complete payment. */
    externalUrl: Scalars['String']['output'];
    /** Target organization for the purpose (BigInt as a decimal string); null when not applicable. */
    orgId: Maybe<Scalars['BigInt']['output']>;
    /** Payment processor handling this checkout. */
    provider: PaymentProvider;
    /** Why the checkout was created; determines the side effect applied on completion. */
    purpose: CheckoutPurpose;
    /** Current lifecycle state, updated by webhook reconciliation (not by the redirect). */
    status: CheckoutStatus;
    /** Access tier being purchased (BigInt as a decimal string); set for APP_ACCESS_PURCHASE, otherwise null. */
    tierId: Maybe<Scalars['BigInt']['output']>;
    /** User who initiated the checkout (BigInt as a decimal string). */
    userId: Scalars['BigInt']['output'];
};
/** An edge in a Checkout connection. */
export type CheckoutEdge = {
    __typename?: 'CheckoutEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: Checkout;
};
export type CheckoutFilterInput = {
    /** Only return checkouts targeting this app (BigInt as a decimal string). */
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Only return checkouts targeting this organization (BigInt as a decimal string). */
    orgId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Only return checkouts using this payment provider. */
    provider?: InputMaybe<PaymentProvider>;
    /** Only return checkouts created for this purpose. */
    purpose?: InputMaybe<CheckoutPurpose>;
    /** Only return checkouts in this lifecycle status. */
    status?: InputMaybe<CheckoutStatus>;
    /** Only return checkouts created by this user (BigInt as a decimal string). */
    userId?: InputMaybe<Scalars['BigInt']['input']>;
};
/** Why the checkout exists. Drives which side effect runs on webhook completion: ORG_WALLET_TOPUP credits an org_wallet; PLAYER_WALLET_TOPUP credits the caller's player_wallet; APP_ACCESS_PURCHASE upserts app_user_access; DONATION inserts donations; PROPERTY_TOKENS credits property_tokens; SHARED_APP_SUBSCRIPTION activates a paid shared-environment app slot. */
export declare enum CheckoutPurpose {
    /** Purchase a user's access to an app at a given tier. Requires appId and tierId. Upserts app_user_access on completion. */
    AppAccessPurchase = "APP_ACCESS_PURCHASE",
    /**
     * Deprecated. Historically a one-off donation to an app. No longer purchasable and rejected at runtime by createCheckout.
     * @deprecated No longer purchasable; use ORG_WALLET_TOPUP or APP_ACCESS_PURCHASE. Retained for historical checkouts.
     */
    Donation = "DONATION",
    /** Add funds to an organization wallet. Requires orgId and amountCents, and the caller must hold the org "manage_billing" permission. Credits the org wallet on completion. */
    OrgWalletTopup = "ORG_WALLET_TOPUP",
    /** Add funds to the caller's own player wallet (player compute P2). Requires amountCents only — any authenticated user may fund their own wallet; no org permission is involved. Credits the player wallet idempotently on completion. */
    PlayerWalletTopup = "PLAYER_WALLET_TOPUP",
    /**
     * Deprecated. Historically a purchase of in-world property tokens. No longer purchasable and rejected at runtime by createCheckout.
     * @deprecated No longer purchasable; use ORG_WALLET_TOPUP or APP_ACCESS_PURCHASE. Retained for historical checkouts.
     */
    PropertyTokens = "PROPERTY_TOKENS",
    /**
     * @deprecated Legacy recurring subscription for a paid shared app slot. No longer purchasable via createCheckout; retained for historical checkouts and webhook reconciliation.
     * @deprecated Shared apps use org wallet hourly usage billing. Publish via publishAppToShared and top up with ORG_WALLET_TOPUP.
     */
    SharedAppSubscription = "SHARED_APP_SUBSCRIPTION"
}
/** Lifecycle state of a Checkout. Updated by webhook reconciliation, not by the redirect URL. */
export declare enum CheckoutStatus {
    /** The user abandoned or canceled the checkout before completion. Terminal state. */
    Canceled = "CANCELED",
    /** Payment succeeded and the purpose side effect was applied (e.g. wallet credited). Terminal success state. */
    Completed = "COMPLETED",
    /** The provider session expired before payment completed (see `expiresAt`). Terminal state. */
    Expired = "EXPIRED",
    /** Payment attempt failed or was declined; see the checkout `error` field for details. Terminal failure state. */
    Failed = "FAILED",
    /** Created and awaiting payment. Initial state right after createCheckout; the user has not finished paying yet. */
    Pending = "PENDING"
}
/** A Relay cursor connection over Checkout records. Page with first/after; pass pageInfo.endCursor back as after for the next page. */
export type CheckoutsConnection = {
    __typename?: 'CheckoutsConnection';
    /** Edges on this page. */
    edges: Array<CheckoutEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** A page of checkouts with offset/limit pagination metadata. */
export type CheckoutsPage = {
    __typename?: 'CheckoutsPage';
    /** The checkouts on this page, ordered newest first. */
    items: Array<Checkout>;
    /** Offset/limit pagination metadata (totalCount, limit, offset) for this result set. */
    pageInfo: PageInfo;
};
/** A persisted 16x16x16-voxel chunk (4096 voxels) of an app's voxel world. Holds the packed voxel-type grid (`voxels`), sparse per-voxel state overrides (`voxelStates`), an optional opaque chunk-level state blob (`chunkState`), and level-of-detail meshes (`lods`). Returned by getChunk/getChunksByDistance and written by updateChunk/updateChunkState/updateChunkLods. */
export type Chunk = {
    __typename?: 'Chunk';
    /** Id of the app that owns this chunk (decimal string). */
    appId: Scalars['ID']['output'];
    /** Timestamp the chunk's binary (d2.bin) was last synced to the CDN/S3, or null if it has never been uploaded. */
    cdnUploadedAt: Maybe<Scalars['DateTime']['output']>;
    /** Server-assigned unique chunk id (decimal string). */
    chunkId: Scalars['ID']['output'];
    /** BASE64-encoded opaque binary blob holding chunk-LEVEL state (distinct from per-voxel state). Decode from base64; null when unset. Written only via updateChunkState and preserved by updateChunk/updateChunkLods. */
    chunkState: Maybe<Scalars['String']['output']>;
    /** This chunk's address in the app's world grid. */
    coordinates: ChunkCoordinates;
    /** Timestamp when this chunk row was first created. */
    createdAt: Scalars['DateTime']['output'];
    /** Level-of-detail (LOD) entries for this chunk (coarser sampled representations), or null if none. Each entry is keyed by integer level (0 = finest) and carries a base64-encoded binary blob. */
    lods: Maybe<Array<LodData>>;
    /** User id (decimal string) of the last writer of this chunk, or null if unknown. */
    owner: Maybe<Scalars['ID']['output']>;
    /** Timestamp of the most recent write to this chunk. */
    updatedAt: Scalars['DateTime']['output'];
    /** Sparse list of per-voxel state overrides (e.g. rotation, atlas, flags) for voxels that need more than a plain type byte. Empty when no voxel carries extra state. */
    voxelStates: Array<VoxelState>;
    /** BASE64-encoded binary blob of the dense voxel-type grid. When present, the DECODED buffer is exactly 4096 bytes: one unsigned byte (voxel type 0-255) per voxel, indexed as x + y*16 + z*256 with x,y,z in 0-15. Null when the chunk has no voxel grid yet. Decode from base64 before reading. */
    voxels: Maybe<Scalars['String']['output']>;
};
/** Authoritative result of an ordinary player claiming one chunk as a new grid under SELF_CLAIM. Grid creation, title assignment, and direct ACL grants are committed atomically. */
export type ChunkClaimResult = {
    __typename?: 'ChunkClaimResult';
    /** Full effective runtime permission-key set materialized for the caller on the new grid after grid limits are applied. */
    effectivePermissionKeys: Array<Scalars['String']['output']>;
    /** Id of the one-chunk grid created for this claim. */
    gridId: Scalars['BigInt']['output'];
    /** High corner of the claimed grid. It equals lowChunk because a player claim covers exactly one chunk. */
    highChunk: ChunkCoordinates;
    /** Low corner of the claimed grid. It equals highChunk because a player claim covers exactly one chunk. */
    lowChunk: ChunkCoordinates;
    /** True when the effective ACL contains both write and run permission for at least one player-code target (server or client). */
    moddable: Scalars['Boolean']['output'];
    /** New current user ownership record created atomically with the grid. */
    ownership: GridOwnership;
    /** App claim policy applied by the server. This mutation succeeds only for SELF_CLAIM. */
    policy: GridClaimPolicy;
};
/** Integer (x, y, z) address of a 16x16x16-voxel chunk within an app's world grid. Each unit step moves one whole chunk (16 voxels) along that axis. Components are signed 64-bit integers serialized as decimal strings (see the BigInt scalar). */
export type ChunkCoordinates = {
    __typename?: 'ChunkCoordinates';
    /** Chunk index along X as a decimal string; +1 = one chunk (16 voxels) further along X. */
    x: Scalars['BigInt']['output'];
    /** Chunk index along Y as a decimal string; +1 = one chunk (16 voxels) further along Y. */
    y: Scalars['BigInt']['output'];
    /** Chunk index along Z as a decimal string; +1 = one chunk (16 voxels) further along Z. */
    z: Scalars['BigInt']['output'];
};
/** Input form of a chunk address (see ChunkCoordinates). Each component is a signed 64-bit integer passed as a decimal string (see the BigInt scalar); all three are required. */
export type ChunkCoordinatesInput = {
    /** Chunk index along X as a decimal string (required). */
    x: Scalars['BigInt']['input'];
    /** Chunk index along Y as a decimal string (required). */
    y: Scalars['BigInt']['input'];
    /** Chunk index along Z as a decimal string (required). */
    z: Scalars['BigInt']['input'];
};
/** Result of getChunkLods: identifying info for a chunk plus the LOD levels that were requested. */
export type ChunkLodsResponse = {
    __typename?: 'ChunkLodsResponse';
    /** Owning app id (decimal string). */
    appId: Scalars['ID']['output'];
    /** Chunk id (decimal string). */
    chunkId: Scalars['ID']['output'];
    /** Address of the chunk. */
    coordinates: ChunkCoordinates;
    /** The requested LOD levels for the chunk. */
    lods: Array<LodData>;
    /** Timestamp when the chunk was last updated. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Payload for updateChunk: upserts a chunk's dense voxel grid and/or per-voxel states and logs each provided state as an individual voxel update. Does NOT modify chunkState or LODs. */
export type ChunkUpdateInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk to create or update. */
    coordinates: ChunkCoordinatesInput;
    /** Optional per-voxel state overrides to write; each entry is also recorded as an individual voxel update. Omit to leave existing states unchanged. */
    voxelStates?: InputMaybe<Array<VoxelStateInput>>;
    /** Optional BASE64-encoded dense voxel grid. The DECODED buffer must be exactly 4096 bytes: one voxel-type byte (0-255) per voxel, indexed x + y*16 + z*256 (x,y,z in 0-15). Omit to leave the existing grid unchanged. */
    voxels?: InputMaybe<Scalars['String']['input']>;
};
/** Result of getVoxelList: the queried chunk address together with its recorded voxel edits. */
export type ChunkVoxelResponse = {
    __typename?: 'ChunkVoxelResponse';
    /** Address of the chunk the voxel edits belong to. */
    coordinates: ChunkCoordinates;
    /** Recorded voxel edits for the chunk, newest first. */
    voxels: Array<Voxel>;
};
/** Recorded voxel edits for a single chunk within a distance query, newest first. */
export type ChunkVoxelUpdatesResponse = {
    __typename?: 'ChunkVoxelUpdatesResponse';
    /** Address of the chunk these voxel edits belong to. */
    coordinates: ChunkCoordinates;
    /** Voxel edits for this chunk, newest first. */
    voxels: Array<Voxel>;
};
/** Paginated result of getChunksByDistance: the chunks found within the search cube plus an echo of the pagination applied. */
export type ChunksByDistanceResponse = {
    __typename?: 'ChunksByDistanceResponse';
    /** Chunks found within the search cube. */
    chunks: Array<Chunk>;
    /** Echo of the `limit` applied to this page, or null if none was supplied. */
    limit: Maybe<Scalars['Int']['output']>;
    /** Echo of the `skip` applied to this page, or null if none was supplied. */
    skip: Maybe<Scalars['Int']['output']>;
};
/** Notification received when another client sends an audio packet (voice chat). Received via the udpNotifications subscription. */
export type ClientAudioNotification = {
    __typename?: 'ClientAudioNotification';
    /** The ID of the app where the audio is coming from. */
    appId: Scalars['BigInt']['output'];
    /** The compressed audio data, base64-encoded. */
    audioData: Scalars['String']['output'];
    /** The X coordinate of the chunk where the audio source is located. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk where the audio source is located. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk where the audio source is located. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** The unique identifier of the audio source (typically the player UUID sending the audio). */
    uuid: Scalars['String']['output'];
};
/** Input for sending a client audio packet (voice chat) to the UDP game server. The audio data is compressed and will be broadcast to nearby players. */
export type ClientAudioPacketInput = {
    /** The ID of the app where the audio is being sent from. */
    appId: Scalars['BigInt']['input'];
    /** The compressed audio data, base64-encoded. */
    audioData: Scalars['String']['input'];
    /** The chunk coordinates where the audio source is located. */
    chunk: ChunkCoordinatesInput;
    /** Decay algorithm for replication: 0 = none, 1 = exponential, 2 = linear 50%, 3 = linear 25%, 4 = linear 10%, 5 = linear 5%. Defaults to 0 (none) for audio packets. */
    decayRate?: InputMaybe<Scalars['Int']['input']>;
    /** Chunk replication distance (0-8). Defaults to 1 for audio packets. Clamped to 0-8. */
    distance?: InputMaybe<Scalars['Int']['input']>;
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on any GenericErrorResponse for this send, delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** A unique identifier for the audio source (typically the player UUID). Must be exactly 32 bytes when encoded as UTF-8. */
    uuid: Scalars['String']['input'];
};
/** Notification received when another client sends a custom event. Received via the udpNotifications subscription. */
export type ClientEventNotification = {
    __typename?: 'ClientEventNotification';
    /** The ID of the app where the event is occurring. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk where the event is located. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk where the event is located. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk where the event is located. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The event type ID (uint16). This determines how the event should be processed. */
    eventType: Scalars['Int']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** The event state data, base64-encoded. The format is defined by the event type. */
    state: Scalars['String']['output'];
    /** The unique identifier of the object controlling this event. */
    uuid: Scalars['String']['output'];
};
/** Input for sending a client event notification to the UDP game server. Events are custom game events that can be used for various gameplay mechanics. The event type and state format are defined by the client/mod. */
export type ClientEventNotificationInput = {
    /** The ID of the app where the event is occurring. */
    appId: Scalars['BigInt']['input'];
    /** The chunk coordinates where the event is located. */
    chunk: ChunkCoordinatesInput;
    /** Decay algorithm for replication: 0 = none, 1 = exponential, 2 = linear 50%, 3 = linear 25%, 4 = linear 10%, 5 = linear 5%. Defaults to 0 (none) for events. */
    decayRate?: InputMaybe<Scalars['Int']['input']>;
    /** Chunk replication distance (0-8). Defaults to 8 for events. Clamped to 0-8. */
    distance?: InputMaybe<Scalars['Int']['input']>;
    /** The event type ID (uint16, 0-65535). This is a client-defined enum that determines how the event should be processed. */
    eventType: Scalars['Int']['input'];
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on any GenericErrorResponse for this send, delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** The event state data, base64-encoded. The format is defined by the event type and is currently only processed by clients. */
    state: Scalars['String']['input'];
    /** A unique identifier for the object controlling this event. Must be exactly 32 bytes when encoded as UTF-8. */
    uuid: Scalars['String']['input'];
};
/** Notification received when another client sends a text message (chat). Received via the udpNotifications subscription. */
export type ClientTextNotification = {
    __typename?: 'ClientTextNotification';
    /** The ID of the app where the text message is coming from. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk where the text source is located. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk where the text source is located. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk where the text source is located. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** The text message content, UTF-8 encoded. Display this to the user. */
    text: Scalars['String']['output'];
    /** The unique identifier of the text source (typically the player UUID sending the message). */
    uuid: Scalars['String']['output'];
};
/** Input for sending a text message (chat) to the UDP game server. The text will be broadcast to nearby players in the same chunk. */
export type ClientTextPacketInput = {
    /** The ID of the app where the text message is being sent from. */
    appId: Scalars['BigInt']['input'];
    /** The chunk coordinates where the text message source is located. */
    chunk: ChunkCoordinatesInput;
    /** Decay algorithm for replication: 0 = none, 1 = exponential, 2 = linear 50%, 3 = linear 25%, 4 = linear 10%, 5 = linear 5%. Defaults to 0 (none) for text packets. */
    decayRate?: InputMaybe<Scalars['Int']['input']>;
    /** Chunk replication distance (0-8). Defaults to 8 for text packets. Clamped to 0-8. */
    distance?: InputMaybe<Scalars['Int']['input']>;
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on any GenericErrorResponse for this send, delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** The text message content, encoded as UTF-8. This will be displayed to nearby players. */
    text: Scalars['String']['input'];
    /** 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'];
};
/** Controls player-code censorship for an app. IMPLICIT_ALLOW admits lawful code by default; ALLOW_LIST requires every code target, including self-authored code, to match an active code/author/org admission. */
export declare enum CodeAdmissionMode {
    AllowList = "ALLOW_LIST",
    ImplicitAllow = "IMPLICIT_ALLOW"
}
/** The identity admitted by an app code allow-list entry: one code listing, one author user, or one authoring organization. */
export declare enum CodeAdmissionSubjectKind {
    Author = "AUTHOR",
    Code = "CODE",
    Org = "ORG"
}
/** One entry in the T11 commerce risk queue (studio/operator moderation). */
export type CommerceRiskFlag = {
    __typename?: 'CommerceRiskFlag';
    /** App the flag belongs to. */
    appId: Scalars['BigInt']['output'];
    /** When the flag was raised. */
    createdAt: Scalars['DateTime']['output'];
    /** Detail note. */
    detail: Maybe<Scalars['String']['output']>;
    /** Flag row id. */
    flagId: Scalars['String']['output'];
    /** Flag kind: 'buyer_velocity', 'listing_velocity', 'same_party', 'chargeback', or 'manual'. */
    kind: Scalars['String']['output'];
    /** Related order UUID, if any. */
    orderId: Maybe<Scalars['String']['output']>;
    /** 'open', 'released', or 'confirmed'. */
    status: Scalars['String']['output'];
    /** Subject: 'user' or 'org'. */
    subjectKind: Scalars['String']['output'];
    /** Subject user or org id. */
    subjectRef: Scalars['BigInt']['output'];
};
/** 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'];
};
/** The synchronous result of a computeInvoke call. Unlike the spatial send surface (dual-success), this is direct RPC: the module ran and this is its output. */
export type ComputeInvokeResult = {
    __typename?: 'ComputeInvokeResult';
    /** Wall-clock duration in microseconds. */
    durationUs: Scalars['Int']['output'];
    /** Fuel consumed by the call. */
    fuelUsed: Scalars['BigInt']['output'];
    /** The module's raw response bytes, base64-encoded. */
    resultBase64: Scalars['String']['output'];
    /** The response decoded as JSON text when it parses as JSON; null otherwise. */
    resultJson: Maybe<Scalars['String']['output']>;
};
/** One entry in the platform's engine-template registry (deployable by name via computeDeployTemplate). */
export type ComputeTemplateInfo = {
    __typename?: 'ComputeTemplateInfo';
    /** What the template does (from its deploy manifest). */
    description: Scalars['String']['output'];
    /** The invoke exports the template binds (its client surface). */
    exports: Array<Scalars['String']['output']>;
    /** The template name (e.g. 'mob-engine', 'matchmaking'). */
    name: Scalars['String']['output'];
};
/** Relay-style pagination metadata for a connection. */
export type ConnectionPageInfo = {
    __typename?: 'ConnectionPageInfo';
    /** Opaque cursor of the last edge in this page; pass as `after`. */
    endCursor: Maybe<Scalars['String']['output']>;
    /** True if more edges exist after `endCursor`. */
    hasNextPage: Scalars['Boolean']['output'];
    /** True if edges exist before `startCursor`. */
    hasPreviousPage: Scalars['Boolean']['output'];
    /** Opaque cursor of the first edge in this page. */
    startCursor: Maybe<Scalars['String']['output']>;
};
/** Operator-set platform ceilings for the per-app WASM compute policy. Each field caps the matching wasm_module_policy knob platform-wide: game-api rejects computeSetPolicy values above the ceiling. A null field means no operator override is stored — game-api falls back to its COMPUTE_PLATFORM_MAX_* env var (bootstrap default), then to the built-in code default. Edits propagate to game-api replicas via replica sync and apply within ~30 seconds, without a game-api restart. */
export type CpComputePlatformCeilings = {
    __typename?: 'CpComputePlatformCeilings';
    /** Max deterministic fuel budget per invoke (fuel_per_invoke ceiling; decimal string). Null = no override (game-api bootstrap default 50000000000). */
    fuelPerInvoke: Maybe<Scalars['BigInt']['output']>;
    /** Max deterministic fuel budget per tick (fuel_per_tick ceiling; decimal string). Null = no override (game-api bootstrap default 10000000000). */
    fuelPerTick: Maybe<Scalars['BigInt']['output']>;
    /** Max host data-API operations per tick (max_db_ops_per_tick ceiling). Null = no override (game-api bootstrap default 500). */
    maxDbOpsPerTick: Maybe<Scalars['Int']['output']>;
    /** Max module-emitted replication bytes per minute (max_egress_bytes_per_min ceiling; decimal string). Null = no override (game-api bootstrap default 100000000). */
    maxEgressBytesPerMin: Maybe<Scalars['BigInt']['output']>;
    /** Max module-emitted replication messages per minute (max_egress_msgs_per_min ceiling). Null = no override (game-api bootstrap default 60000). */
    maxEgressMsgsPerMin: Maybe<Scalars['Int']['output']>;
    /** Max WASM linear memory per module instance in MiB (max_memory_mb ceiling). Null = no override (game-api bootstrap default 512). */
    maxMemoryMb: Maybe<Scalars['Int']['output']>;
    /** Max compute modules per app (wasm_module_policy.max_modules ceiling). Null = no override (game-api bootstrap default 100). */
    maxModules: Maybe<Scalars['Int']['output']>;
    /** Max wall-clock watchdog deadline per entry call in milliseconds (max_run_ms ceiling). Null = no override (game-api bootstrap default 5000). */
    maxRunMs: Maybe<Scalars['Int']['output']>;
    /** Max module state bytes written per minute (max_state_bytes_per_min ceiling; decimal string). Null = no override (game-api bootstrap default 1073741824). */
    maxStateBytesPerMin: Maybe<Scalars['BigInt']['output']>;
    /** Max module state saves per minute (max_state_writes_per_min ceiling). Null = no override (game-api bootstrap default 6000). */
    maxStateWritesPerMin: Maybe<Scalars['Int']['output']>;
    /** Max tick trigger rate in Hz per module (max_tick_hz ceiling). Null = no override (game-api bootstrap default 60). */
    maxTickHz: Maybe<Scalars['Int']['output']>;
    /** When the ceilings row was last updated (UTC). */
    updatedAt: Scalars['DateTime']['output'];
    /** users.user_id of the operator who last updated the ceilings. Null when never edited. */
    updatedByUserId: Maybe<Scalars['String']['output']>;
};
/** Patch for cpSetComputePlatformCeilings. Omitted fields stay unchanged; a field set to an explicit null clears that override (game-api falls back to its COMPUTE_PLATFORM_MAX_* env var, then the code default); a value sets the ceiling. All values must be > 0. At least one field is required. */
export type CpSetComputePlatformCeilingsInput = {
    /** Max fuel per invoke (decimal string). > 0; explicit null clears the override; omit to leave unchanged. */
    fuelPerInvoke?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max fuel per tick (decimal string). > 0; explicit null clears the override; omit to leave unchanged. */
    fuelPerTick?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max host data-API operations per tick. > 0; explicit null clears the override; omit to leave unchanged. */
    maxDbOpsPerTick?: InputMaybe<Scalars['Int']['input']>;
    /** Max module-emitted replication bytes per minute (decimal string). > 0; explicit null clears the override; omit to leave unchanged. */
    maxEgressBytesPerMin?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max module-emitted replication messages per minute. > 0; explicit null clears the override; omit to leave unchanged. */
    maxEgressMsgsPerMin?: InputMaybe<Scalars['Int']['input']>;
    /** Max WASM memory per module instance in MiB. > 0; explicit null clears the override; omit to leave unchanged. */
    maxMemoryMb?: InputMaybe<Scalars['Int']['input']>;
    /** Max compute modules per app. > 0; explicit null clears the override; omit to leave unchanged. */
    maxModules?: InputMaybe<Scalars['Int']['input']>;
    /** Max watchdog deadline per entry call in milliseconds. > 0; explicit null clears the override; omit to leave unchanged. */
    maxRunMs?: InputMaybe<Scalars['Int']['input']>;
    /** Max module state bytes written per minute (decimal string). > 0; explicit null clears the override; omit to leave unchanged. */
    maxStateBytesPerMin?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max module state saves per minute. > 0; explicit null clears the override; omit to leave unchanged. */
    maxStateWritesPerMin?: InputMaybe<Scalars['Int']['input']>;
    /** Max tick rate in Hz per module. > 0; explicit null clears the override; omit to leave unchanged. */
    maxTickHz?: InputMaybe<Scalars['Int']['input']>;
};
/** Input for creating a new app access tier. */
export type CreateAccessTierInput = {
    /** Numeric id of the app the tier belongs to. The caller must hold manage_access_tiers on this app. */
    appId: Scalars['BigInt']['input'];
    /** Optional marketing description of the tier. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Optional; whether this is the app's default tier. Defaults to false. */
    isDefault?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional; whether the tier is free. Defaults to false. */
    isFree?: InputMaybe<Scalars['Boolean']['input']>;
    /** Tier display name (max 128 chars). */
    name: Scalars['String']['input'];
    /** Optional runtime permission keys to grant on this tier (must be valid runtimePermissions). Defaults to ["access"] when omitted. */
    permissionKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Optional sort order (ascending). Defaults to 0. */
    tierOrder?: InputMaybe<Scalars['Int']['input']>;
};
export type CreateActorInput = {
    /** App (game) the actor belongs to. Required. BigInt sent as a decimal string. */
    appId: Scalars['BigInt']['input'];
    /** Optional avatar to attach; if provided it must be owned by the caller. BigInt sent as a decimal string. */
    avatarId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Initial chunk-grid coordinates (x, y, z as int64 BigInt decimal strings). Required. */
    chunk: ChunkCoordinatesInput;
    /** Optional owner-only private state blob, base64-encoded binary. */
    privateState?: InputMaybe<Scalars['String']['input']>;
    /** Optional public state blob, base64-encoded binary. */
    publicState?: InputMaybe<Scalars['String']['input']>;
    /** Actor id: exactly 32 ASCII characters (the UDP-wire actor id), NOT a hyphenated RFC-4122 UUID. Required and must be unique. */
    uuid: Scalars['String']['input'];
};
/** Create an owner/app-scoped session with pinned human mode, project/grid context, model, policy, registry, and provider disclosure choice. */
export type CreateAgentSessionInput = {
    /** App tenant; the bearer credential must be an unexpired app token for this exact app and the caller must hold use_studio_agent. */
    appId: Scalars['BigInt']['input'];
    /** Optional selected grid context; selection grants no authority. */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Human-selected initial ASK, BUILD, or PLAY mode. */
    mode: CrowdyStudioAgentMode;
    /** Optional private owner project UUID. Required for BUILD; cross-owner/app ids return the same not-found shape. */
    projectId?: InputMaybe<Scalars['String']['input']>;
    /** Optional explicit first-use consent for selected private project source. Omit/false for message-only or metadata-only sessions. */
    providerDataConsent?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional requested allowlisted model. Omit for the platform default. */
    requestedModel?: InputMaybe<Scalars['String']['input']>;
};
/** Input payload for creating a new app. */
export type CreateAppInput = {
    /** Datacenter the app will live in, e.g. 'or' or 'va'. Query placeableDatacenters for the accepted codes and whether each can currently hold an app. REQUIRED and permanent: an app is distributed on app_id, so all of its data lives on one node in one datacenter and that is fixed when the id is minted. Creation FAILS if the datacenter is unknown to this deployment or holds no capacity, rather than creating an app that cannot be routed. There is no default — the instance answering this call may be in a different datacenter from the one you want. Moving an app afterwards is an operator action. */
    datacenter: Scalars['String']['input'];
    /** Optional short plain-text description for listings. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Optional JSON-encoded marketplace metadata string (see App.metadata). Defaults to an empty object when omitted. */
    metadata?: InputMaybe<Scalars['String']['input']>;
    /** Display name of the app (1-256 characters). */
    name: Scalars['String']['input'];
    /** Numeric id of the organization that will own the app. The caller must hold the manage_apps permission on this org. */
    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 LIVE when omitted. */
    status?: InputMaybe<AppStatus>;
    /** Optional initial visibility. Defaults to PUBLIC when omitted. */
    visibility?: InputMaybe<AppVisibility>;
};
export type CreateAvatarInput = {
    /** Optional avatar name; defaults to "Default Avatar" when omitted. */
    name?: InputMaybe<Scalars['String']['input']>;
};
/** Create a channel in an app. */
export type CreateChannelInput = {
    /** The app (tenant) the channel belongs to. */
    appId: Scalars['BigInt']['input'];
    /** Optional free-text description of the channel. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** When true (default), new members are auto-granted send_messages so they can post (open chat channel). When false, only roles you grant may post (announce/read-only channel). */
    membersCanSend?: InputMaybe<Scalars['Boolean']['input']>;
    /** open | request | invite | admin. Defaults to the app policy. */
    membershipPolicy?: InputMaybe<Scalars['String']['input']>;
    /** Display name for the channel (max 128 chars; unique per app+type). */
    name: Scalars['String']['input'];
};
export type CreateCheckoutInput = {
    /** Charge amount in minor currency units (cents) of `currency`, as a BigInt decimal string. Required for ORG_WALLET_TOPUP. */
    amountCents?: InputMaybe<Scalars['BigInt']['input']>;
    /** Target app (BigInt as a decimal string). Required for APP_ACCESS_PURCHASE and SHARED_APP_SUBSCRIPTION. */
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Absolute URL the provider redirects to if the user cancels. Optional; a server default is used if omitted. */
    cancelUrl?: InputMaybe<Scalars['String']['input']>;
    /** ISO-4217 currency code, lowercase (e.g. "usd"). Defaults to "usd". */
    currency?: InputMaybe<Scalars['String']['input']>;
    /** Optional idempotency key. Recommended for retries: replaying with the same key and identical input returns the first checkout instead of opening a second provider session; the same key with different input returns IDEMPOTENCY_CONFLICT. Keys expire after 24h. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Target organization (BigInt as a decimal string). Required for ORG_WALLET_TOPUP; ignored for other purposes. */
    orgId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Shared-environment plan id (a shared_env_plans.plan_id, BigInt as a decimal string). Required for SHARED_APP_SUBSCRIPTION. */
    planId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Payment processor to use for this checkout (STRIPE or PAYPAL). */
    provider: PaymentProvider;
    /** What the checkout is for; determines which other fields are required and the side effect applied on completion. DONATION and PROPERTY_TOKENS are rejected. */
    purpose: CheckoutPurpose;
    /** Absolute URL the provider redirects to after a successful payment. Optional; a server default is used if omitted. */
    successUrl?: InputMaybe<Scalars['String']['input']>;
    /** Access tier to purchase (BigInt as a decimal string). Required for APP_ACCESS_PURCHASE. */
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
};
/** Instantiate a container (runtime entity). */
export type CreateContainerInput = {
    /** The app (tenant) the container belongs to. */
    appId: Scalars['BigInt']['input'];
    /** Optional description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Human-friendly display name. */
    displayName: Scalars['String']['input'];
    /** JSON object of metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** Owner user id; defaults to the caller for member/owner instantiation. */
    ownerUserId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Initial property values for the container. */
    properties?: InputMaybe<Array<SeedPropertyInput>>;
    /** Optional session to create the container in (omit for app-global). */
    sessionId?: InputMaybe<Scalars['String']['input']>;
    /** The container type to instantiate. */
    typeName: Scalars['String']['input'];
};
/** Lazily create a private project by copying the authenticated author’s latest source versions from existing self-authored player modules. */
export type CreateCrowdyStudioProjectFromModulesInput = {
    /** App tenant containing the authored modules. */
    appId: Scalars['BigInt']['input'];
    /** Existing self-authored CLIENT module name to copy; at least one module name is required. */
    clientModuleName?: InputMaybe<Scalars['String']['input']>;
    /** Grid containing the authored modules. Current ownership is not required to recover one’s own source, but deployment is rechecked separately. */
    gridId: Scalars['BigInt']['input'];
    /** Optional 24-hour retry key. The operation also returns an already-created active project with the same module affinity. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Optional project name. Omit to derive a bounded name from the imported module name(s). */
    projectName?: InputMaybe<Scalars['String']['input']>;
    /** Existing self-authored SERVER module name to copy; at least one module name is required. */
    serverModuleName?: InputMaybe<Scalars['String']['input']>;
};
/** Create a private player-owned project, optionally with bounded initial files for either target. */
export type CreateCrowdyStudioProjectInput = {
    /** Supported guest ABI pin; defaults to ABI 0. */
    abiVersion?: InputMaybe<Scalars['Int']['input']>;
    /** App tenant. Requires an app-scoped token for this exact app; the project is owned by the authenticated user. */
    appId: Scalars['BigInt']['input'];
    /** Optional stable crate-style CLIENT module name. It must differ from the server name. */
    clientModuleName?: InputMaybe<Scalars['String']['input']>;
    /** Optional private project description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Optional grid affinity in the same app. Affinity does not grant deployment permission and survives ownership transfer. */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Optional retry key. Same user, operation, key, and input replay the first result for 24 hours; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Optional initial source files. At most 16 total and at most 8/256 KiB independently per target. */
    initialFiles?: InputMaybe<Array<CrowdyStudioProjectFileInput>>;
    /** Player-facing project name. */
    name: Scalars['String']['input'];
    /** Optional editor pairing preference; defaults to PAIRED. */
    pairingPreference?: InputMaybe<CrowdyStudioPairingPreference>;
    /** Supported crowdy-compute-sdk pin; defaults to the current 0.1.5 authoring pin. */
    sdkVersion?: InputMaybe<Scalars['String']['input']>;
    /** Optional stable crate-style SERVER module name. Deployment rechecks current authority. */
    serverModuleName?: InputMaybe<Scalars['String']['input']>;
};
/** Defines a new grid by its app and two opposite corner chunks. The corners are normalized server-side into a low/high chunk box, so corner order is irrelevant and a single chunk (corner1 == corner2) is allowed. */
export type CreateGridInput = {
    /** The app (tenant) the grid belongs to. */
    appId: Scalars['BigInt']['input'];
    /** One corner of the grid box, in chunk coordinates. */
    corner1: ChunkCoordinatesInput;
    /** The opposite corner of the grid box, in chunk coordinates. May equal corner1 for a single-chunk grid. */
    corner2: ChunkCoordinatesInput;
};
export type CreateGridListingInput = {
    /** App the listing belongs to. */
    appId: Scalars['BigInt']['input'];
    /** JSON bounds/placement config (blueprint listings). */
    blueprintConfigJson?: InputMaybe<Scalars['String']['input']>;
    /** Player-code keys the sale confers (e.g. write/run server/client). */
    conferredPermissionKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Store description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** The concrete grid id being sold (concrete listings). */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** 'blueprint' or 'concrete'. */
    kind: Scalars['String']['input'];
    /** Display name. */
    name: Scalars['String']['input'];
    /** Price in cents. */
    priceCents: Scalars['Int']['input'];
    /** JSON per-grid quota preset bound on purchase. */
    quotaPresetJson?: InputMaybe<Scalars['String']['input']>;
    /** Resale policy: 'no_resale' (default), 'resale_free', or 'resale_with_studio_cut'. */
    resalePolicy?: InputMaybe<Scalars['String']['input']>;
    /** Studio cut (bps) taken on resales, when resale_with_studio_cut. */
    studioCutBps?: InputMaybe<Scalars['Int']['input']>;
};
/** Result of createGrid. This is a hybrid result rather than a thrown error: inspect `error` first. When `error` is NO_ERROR the call succeeded and `grid` is populated; otherwise `grid` is null and `error` explains why. */
export type CreateGridResponse = {
    __typename?: 'CreateGridResponse';
    /** A UDP-style error code (the same ErrorType enum the realtime/UDP servers use). NO_ERROR (0) means success; non-zero values describe the failure, e.g. NO_MATCHING_GRID_ASSIGNMENT, GRID_OUTSIDE_ASSIGNMENT, GRID_OVERLAPS_EXISTING, GRID_ALREADY_EXISTS, or UNKNOWN_ERROR. */
    error: UdpErrorCode;
    /** The created grid on success; null when `error` is non-zero. */
    grid: Maybe<Grid>;
};
/** Create a custom role within a group (team or channel), granting group permission keys. */
export type CreateGroupRoleInput = {
    /** The group (team/channel) the role belongs to. */
    groupId: Scalars['BigInt']['input'];
    /** Group permission key strings this role grants (e.g. manage_members, manage_roles, manage_group, send_messages). Must be valid keys for the group type; each max 64 chars, unique. Defaults to none. */
    permissions?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Sort/precedence rank (higher = more senior). Defaults to 0. */
    rank?: InputMaybe<Scalars['Int']['input']>;
    /** Role display name (max 128 chars; unique within the group). */
    roleName: Scalars['String']['input'];
};
export type CreateOrgRoleInput = {
    /** Optional human-readable description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Organization to create the role in (BigInt as string). */
    orgId: Scalars['BigInt']['input'];
    /** Permission keys (from orgPermissions) to grant. Unknown keys are silently dropped. */
    permissions: Array<Scalars['String']['input']>;
    /** Role name (max 128 characters). */
    roleName: Scalars['String']['input'];
};
export type CreateOrgTokenInput = {
    /** Optional expiry timestamp; omit for a non-expiring token. */
    expiresAt?: InputMaybe<Scalars['DateTime']['input']>;
    /** Optional human-readable label (max 256 characters). */
    label?: InputMaybe<Scalars['String']['input']>;
    /** Organization to mint the token for (BigInt as string). */
    orgId: Scalars['BigInt']['input'];
};
export type CreateOrganizationInput = {
    /** Organization display name (1-256 characters). */
    name: Scalars['String']['input'];
    /** Unique URL slug; lowercase letters, numbers, and dashes only (1-128 characters). */
    slug: Scalars['String']['input'];
};
/** Create a grid-confined player automation. Trigger and action are strict JSON shapes; owner/app/grid selectors cannot be supplied. */
export type CreatePlayerAutomationInput = {
    /** Strict action JSON. Use {"kind":"studio_model_invoke","functionName":"...","selfContainerId":"...","params":{}} or {"kind":"player_compute_invoke","moduleName":"...","exportName":"...","params":{}}. Selectors and caller identity are forbidden. */
    actionJson: Scalars['String']['input'];
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Circuit cooldown in milliseconds. Default 60000; minimum 1. */
    cooldownMs?: InputMaybe<Scalars['Int']['input']>;
    /** Optional description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Consecutive failures before the circuit opens. Default 5; minimum 1. */
    failureThreshold?: InputMaybe<Scalars['Int']['input']>;
    /** Grid that confines the automation. */
    gridId: Scalars['BigInt']['input'];
    /** Per-automation run limit per rolling minute. Default 60; minimum 1. */
    maxRunsPerMinute?: InputMaybe<Scalars['Int']['input']>;
    /** Name unique for the current owner in this grid. */
    name: Scalars['String']['input'];
    /** Strict trigger JSON. Schedule: {"kind":"schedule","scheduleKind":"interval","intervalMs":2000} or cron with cronExpr. Event: {"kind":"event","eventKind":"owner_container_changed|grid_actor_changed|grid_voxel_changed|compute_event"}; compute_event may include eventName. */
    triggerJson: Scalars['String']['input'];
};
/** Create a flexible player-owned model container inside one grid. The caller must currently own the grid; owner identity cannot be supplied. */
export type CreatePlayerModelContainerInput = {
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Optional player-facing name, unique within the owner/grid/type tuple. */
    displayName?: InputMaybe<Scalars['String']['input']>;
    /** Grid that confines the container. */
    gridId: Scalars['BigInt']['input'];
    /** Optional JSON object stored as untyped container state. */
    stateJson?: InputMaybe<Scalars['String']['input']>;
    /** Flexible instance kit key. Defaults to 'PlayerData'; this does not author a studio model type. */
    typeKey?: InputMaybe<Scalars['String']['input']>;
};
/** Input for createPortalAuthorizationCode: the Overworld (identity origin, holding the session token) mints a one-time code the destination game exchanges for an app token. Browser handoff path; pair with a PKCE verifier held by the destination game origin. */
export type CreatePortalAuthorizationCodeInput = {
    /** Numeric id of the target app the player is portaling into. */
    appId: Scalars['BigInt']['input'];
    /** PKCE code challenge (recommended). Base64url(SHA-256(verifier)) when method is S256. The destination game generates the verifier+challenge so the verifier never leaves its origin. */
    codeChallenge: Scalars['String']['input'];
    /** PKCE method: "S256" (default, recommended) or "plain". */
    codeChallengeMethod?: InputMaybe<Scalars['String']['input']>;
    /** Where to redirect the player after issuing the code. Must match the target app's configured launch_url origin when set. */
    redirectUri: Scalars['String']['input'];
};
/** Create a runtime session. */
export type CreateSessionInput = {
    /** The app (tenant) the session belongs to. */
    appId: Scalars['BigInt']['input'];
    /** JSON object of session metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** Optional session name. */
    name?: InputMaybe<Scalars['String']['input']>;
    /** Initial participants besides the creator. */
    participantUserIds?: InputMaybe<Array<Scalars['BigInt']['input']>>;
};
/** Create a team in an app. */
export type CreateTeamInput = {
    /** The app (tenant) the team belongs to. */
    appId: Scalars['BigInt']['input'];
    /** Optional free-text description of the team. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** open | request | invite | admin. Defaults to the app policy. */
    membershipPolicy?: InputMaybe<Scalars['String']['input']>;
    /** Display name for the team (max 128 chars; unique per app+type). */
    name: Scalars['String']['input'];
};
export type CreateUserAppStateInput = {
    /** App (game) id to scope the state to. Required. BigInt sent as a decimal string. */
    appId: Scalars['BigInt']['input'];
    /** Per-app user state as base64-encoded binary, at most 1,048,576 base64 characters (~768 KiB binary); larger payloads draw a structured validation error. Omit or send null to clear it. */
    state?: InputMaybe<Scalars['String']['input']>;
};
/** Single-use human decision lifecycle for one canonical argument hash. */
export declare enum CrowdyStudioAgentApprovalStatus {
    /** Used exactly once for dispatch/execution. */
    Consumed = "CONSUMED",
    /** Human denied the exact call. */
    Denied = "DENIED",
    /** TTL elapsed before use. */
    Expired = "EXPIRED",
    /** Granted but not yet atomically consumed. */
    Granted = "GRANTED",
    /** Awaiting the matching attached human. */
    Pending = "PENDING",
    /** Invalidated by context or policy change. */
    Revoked = "REVOKED"
}
/** One allowed Agentic Studio mode that cannot perform the work the mode exists for, because the tool or risk-class allowlist excludes every tool that would do it. This is a capability shortfall, not a permission failure: the policy really is enabled and the mode really is allowed, so no disable reason code describes it. */
export type CrowdyStudioAgentCapabilityGap = {
    __typename?: 'CrowdyStudioAgentCapabilityGap';
    /** Stable code. NO_TOOLS: the tool allowlist is empty, so the agent can only talk. NO_WRITE_RISK: tools are allowed but every risk class that would let this mode change something is not, so BUILD can read and cannot build, and PLAY can observe and cannot act. */
    code: Scalars['String']['output'];
    /** Safe operator-facing explanation naming the missing risk classes. Never includes provider bodies or secrets. */
    detail: Scalars['String']['output'];
    /** The allowed mode that has nothing useful to call. */
    mode: CrowdyStudioAgentMode;
};
/** The answering ck-api instance's Agentic Studio capability: the models it carries with their pinned prices, the implemented tool registry with risk classes, and the full mode and risk-class value sets a policy may draw from. This is deployed configuration, not stored policy — a platform policy naming anything absent here is accepted and then runs nothing. */
export type CrowdyStudioAgentCatalog = {
    __typename?: 'CrowdyStudioAgentCatalog';
    /** The answering instance's datacenter (CK_DATACENTER), or null. */
    datacenterCode: Maybe<Scalars['String']['output']>;
    /** Default model id, or null when the agent is disabled here. */
    defaultModelId: Maybe<Scalars['String']['output']>;
    /** Whether CROWDY_STUDIO_AGENT_ENABLED is set on this instance. False means every list below is empty and no policy can make the agent run here. */
    instanceEnabled: Scalars['Boolean']['output'];
    /** Which process answered (CKS_RUNTIME_SERVER_ID or hostname), because this is a per-instance answer. */
    instanceId: Maybe<Scalars['String']['output']>;
    /** Models this instance carries, sorted by id. Empty when the agent is disabled here. */
    models: Array<CrowdyStudioAgentCatalogModel>;
    /** Every mode value a policy allowlist may contain. */
    modes: Array<CrowdyStudioAgentMode>;
    /** Platform policy contract version the instance enforces. */
    platformPolicyVersion: Scalars['String']['output'];
    /** Provider the instance would route to: 'openrouter', or 'fake' outside production. */
    provider: Scalars['String']['output'];
    /** Digest over the whole compiled-in tool registry. Two instances reporting different digests are running different tool sets. */
    registryDigest: Scalars['String']['output'];
    /** Every risk-class value a policy allowlist may contain. */
    riskClasses: Array<CrowdyStudioAgentRiskClass>;
    /** Implemented tools, sorted by logical name. Present whether or not the agent is enabled, because the registry is compiled in. */
    tools: Array<CrowdyStudioAgentCatalogTool>;
};
/** One model the answering ck-api instance carries, with the pinned price it will meter against. */
export type CrowdyStudioAgentCatalogModel = {
    __typename?: 'CrowdyStudioAgentCatalogModel';
    /** Pinned input price in micro-USD per million tokens. */
    inputMicrosPerMillion: Scalars['Int']['output'];
    /** Whether this is the instance's default model (CROWDY_STUDIO_AGENT_DEFAULT_MODEL). */
    isDefault: Scalars['Boolean']['output'];
    /** Exact provider model id, as a policy would name it. */
    modelId: Scalars['String']['output'];
    /** Pinned output price in micro-USD per million tokens. */
    outputMicrosPerMillion: Scalars['Int']['output'];
    /** Whether the instance would accept a run on this model: it is in the instance allowlist and has a positive pinned price in both directions. A zero price is only reachable with the non-production fake provider, which cannot reserve cost. */
    selectable: Scalars['Boolean']['output'];
};
/** One implemented crowdy.agent-tools/1 tool, named exactly as a policy allowlist must name it. */
export type CrowdyStudioAgentCatalogTool = {
    __typename?: 'CrowdyStudioAgentCatalogTool';
    /** Whether every call needs exact human approval regardless of policy. */
    approvalRequired: Scalars['Boolean']['output'];
    /** Trusted boundary that runs it: SERVER or BROWSER. */
    executor: CrowdyStudioAgentToolExecutor;
    /** Modes the tool is available in. */
    modes: Array<CrowdyStudioAgentMode>;
    /** Logical dotted tool name. This is the string an allowedToolNames entry must equal. */
    name: Scalars['String']['output'];
    /** Server-classified risk. Allowing the class is necessary but not sufficient: an approval-gated tool still requires exact human approval. */
    riskClass: CrowdyStudioAgentRiskClass;
    /** What the tool does, from its canonical descriptor. */
    summary: Scalars['String']['output'];
};
/** Typed union of ordered, replayable version 1 session facts. Delivery is at-least-once; seq and eventId support deduplication. */
export type CrowdyStudioAgentEvent = AgentApprovalEvent | AgentBudgetEvent | AgentCheckpointEvent | AgentLeaseEvent | AgentLifecycleEvent | AgentMessageEvent | AgentRunEvent | AgentToolEvent;
/** Version 1 durable ordered event vocabulary. */
export declare enum CrowdyStudioAgentEventType {
    /** Approval was atomically consumed once. */
    ApprovalConsumed = "APPROVAL_CONSUMED",
    /** Human denied the pending exact approval. */
    ApprovalDenied = "APPROVAL_DENIED",
    /** Approval TTL elapsed. */
    ApprovalExpired = "APPROVAL_EXPIRED",
    /** Human granted the pending exact approval. */
    ApprovalGranted = "APPROVAL_GRANTED",
    /** Exact argument-hash human approval was requested. */
    ApprovalRequested = "APPROVAL_REQUESTED",
    /** Bounded coalesced assistant text; final message is canonical. */
    AssistantChunk = "ASSISTANT_CHUNK",
    /** Canonical final assistant response. */
    AssistantMessage = "ASSISTANT_MESSAGE",
    /** Provider reservation/accounting state changed. */
    BudgetUpdated = "BUDGET_UPDATED",
    /** Immutable private pre-image checkpoint was created. */
    CheckpointCreated = "CHECKPOINT_CREATED",
    /** Checkpoint restored as a new project revision. */
    CheckpointRestored = "CHECKPOINT_RESTORED",
    /** A new monotonic client epoch attached and fenced older tabs. */
    ClientAttached = "CLIENT_ATTACHED",
    /** The interactive browser detached. */
    ClientDetached = "CLIENT_DETACHED",
    /** Authoritative context changed and old authority was fenced. */
    ContextChanged = "CONTEXT_CHANGED",
    /** Lease reached its expiry. */
    LeaseExpired = "LEASE_EXPIRED",
    /** Workspace or Play lease was granted. */
    LeaseGranted = "LEASE_GRANTED",
    /** Lease was immediately revoked. */
    LeaseRevoked = "LEASE_REVOKED",
    /** Human selected ASK, BUILD, or PLAY. */
    ModeSelected = "MODE_SELECTED",
    /** Human cancellation became durable. */
    RunCancelled = "RUN_CANCELLED",
    /** Run reached a typed terminal failure. */
    RunFailed = "RUN_FAILED",
    /** Active run entered a recoverable pause. */
    RunPaused = "RUN_PAUSED",
    /** Safety preemption became durable. */
    RunPreempted = "RUN_PREEMPTED",
    /** A leased worker started the serialized run. */
    RunStarted = "RUN_STARTED",
    /** Run completed successfully. */
    RunSucceeded = "RUN_SUCCEEDED",
    /** Session closed and retention cleanup began. */
    SessionClosed = "SESSION_CLOSED",
    /** Session and pinned policy/registry context were created. */
    SessionCreated = "SESSION_CREATED",
    /** Human paused the session and revoked capabilities. */
    SessionPaused = "SESSION_PAUSED",
    /** Human explicitly resumed after context revalidation. */
    SessionResumed = "SESSION_RESUMED",
    /** Human denied the exact proposal. */
    ToolDenied = "TOOL_DENIED",
    /** Typed browser call was durably dispatched once. */
    ToolDispatched = "TOOL_DISPATCHED",
    /** Typed executor reported a safe terminal failure. */
    ToolFailed = "TOOL_FAILED",
    /** Effect may have occurred; no blind retry is allowed. */
    ToolOutcomeUnknown = "TOOL_OUTCOME_UNKNOWN",
    /** Provider proposal passed exact name and input validation. */
    ToolProposed = "TOOL_PROPOSED",
    /** Typed executor output passed validation. */
    ToolSucceeded = "TOOL_SUCCEEDED",
    /** Recorded tool deadline elapsed. */
    ToolTimedOut = "TOOL_TIMED_OUT",
    /** Redacted bounded human message accepted for one run. */
    UserMessage = "USER_MESSAGE"
}
/** Funding seam for Agentic Studio. The development pilot is platform-funded and never debits a player wallet; payer/rate-card fields are reserved for a later contract. */
export type CrowdyStudioAgentFundingPolicy = {
    __typename?: 'CrowdyStudioAgentFundingPolicy';
    /** Funding mode. The pilot always returns 'PLATFORM_FUNDED'. */
    billingMode: Scalars['String']['output'];
    /** Future payer kind. The pilot always returns 'PLATFORM'. */
    payerKind: Scalars['String']['output'];
    /** Future rate-card UUID; null throughout the platform-funded pilot. */
    rateCardId: Maybe<Scalars['String']['output']>;
    /** Whether this policy can debit a player wallet. Always false in the pilot. */
    walletDebitEnabled: Scalars['Boolean']['output'];
};
/** Lifecycle of a short-lived workspace or Play capability. */
export declare enum CrowdyStudioAgentLeaseStatus {
    /** Usable until its exact expiry/context changes. */
    Active = "ACTIVE",
    /** Expired and cannot be renewed by the model. */
    Expired = "EXPIRED",
    /** Explicitly or automatically revoked. */
    Revoked = "REVOKED"
}
/** Capability family represented by a lease. */
export declare enum CrowdyStudioAgentLeaseType {
    /** Visible human-granted browser control lease, capped at ten minutes. */
    Play = "PLAY",
    /** Thirty-second server-acquired lease bound to project revision and target write scopes. */
    Workspace = "WORKSPACE"
}
/** Human-selected authority mode. The model cannot change modes or elevate itself. */
export declare enum CrowdyStudioAgentMode {
    /** Read bounded project, diagnostics, policy, and host context; no project or game writes. */
    Ask = "ASK",
    /** Permit routine checkpointed project edits and draft tests under target write/run permissions and a workspace lease; live deployment is available only through an exact human approval. */
    Build = "BUILD",
    /** Permit bounded browser-host observation and gameplay tools only through a visible, human-granted, scoped lease; human input and policy/context changes preempt control immediately. */
    Play = "PLAY"
}
/** Per-player UTC-day cumulative limits plus player/app concurrency ceilings. */
export type CrowdyStudioAgentPlayerDayLimits = {
    __typename?: 'CrowdyStudioAgentPlayerDayLimits';
    /** Maximum draft compile submissions per player per UTC day. */
    compiles: Scalars['Int']['output'];
    /** Maximum concurrent agent runs across the app. */
    concurrentRunsPerApp: Scalars['Int']['output'];
    /** Maximum concurrent sessions for one player. */
    concurrentSessions: Scalars['Int']['output'];
    /** Maximum input tokens per player per UTC day. */
    inputTokens: Scalars['BigInt']['output'];
    /** Maximum output tokens per player per UTC day. */
    outputTokens: Scalars['BigInt']['output'];
    /** Maximum provider cost per player per UTC day, in micro-USD. */
    providerCostMicrousd: Scalars['BigInt']['output'];
    /** Maximum provider requests per player per UTC day. */
    providerRequests: Scalars['Int']['output'];
    /** Maximum reasoning tokens per player per UTC day. */
    reasoningTokens: Scalars['BigInt']['output'];
    /** Maximum tool calls per player per UTC day. */
    toolCalls: Scalars['Int']['output'];
    /** Maximum total provider tokens per player per UTC day. */
    totalTokens: Scalars['BigInt']['output'];
};
/** Patch for per-player/day and app concurrency limits. Omitted values stay unchanged; supplied values are clamped down to platform ceilings. */
export type CrowdyStudioAgentPlayerDayLimitsInput = {
    /** Maximum draft compile submissions per player per UTC day. */
    compiles?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum concurrent Agentic Studio runs across the app. */
    concurrentRunsPerApp?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum concurrent Agentic Studio sessions for one player. */
    concurrentSessions?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum input tokens per player per UTC day. */
    inputTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum output tokens per player per UTC day. */
    outputTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum provider cost per player per UTC day, in micro-USD. */
    providerCostMicrousd?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum provider requests per player per UTC day. */
    providerRequests?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum reasoning tokens per player per UTC day. */
    reasoningTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum tool calls per player per UTC day. */
    toolCalls?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum total provider tokens per player per UTC day. */
    totalTokens?: InputMaybe<Scalars['BigInt']['input']>;
};
/** Management's Agentic Crowdy Studio policy publication. EFFECTIVE values are the fail-closed platform/app intersection; an app can never widen platform models, tools, modes, risks, budgets, retention, or privacy. Game API runtime enforcement still requires a fresh validated replica. */
export type CrowdyStudioAgentPolicy = {
    __typename?: 'CrowdyStudioAgentPolicy';
    /** Exact model ids allowed by this layer/intersection. Empty denies all models. */
    allowedModelIds: Array<Scalars['String']['output']>;
    /** Human-selectable modes allowed by this layer/intersection. */
    allowedModes: Array<CrowdyStudioAgentMode>;
    /** Allowed tool risk classes. Required approval classes remain approval-gated even when listed. Empty follows the same rule as allowedToolNames: deny-all on PLATFORM, inherit-the-platform on APP. An EFFECTIVE policy can never be enabled with an empty list, because crowdy.studio-agent-policy/1 requires a non-empty risk intersection; that case reports AGENT_SCOPE_DENIED. */
    allowedRiskClasses: Array<CrowdyStudioAgentRiskClass>;
    /** Exact crowdy.agent-tools/1 logical tool names allowed by this layer/intersection. Empty means opposite things at the two layers: on PLATFORM it denies every tool, because the platform layer is the ceiling; on APP it expresses no narrowing, so EFFECTIVE inherits the platform list unchanged. An app therefore cannot reach a tool the platform has not published, and an operator who later adds one widens every app that names none. */
    allowedToolNames: Array<Scalars['String']['output']>;
    /** App id for APP/EFFECTIVE policy; null for platform policy. */
    appId: Maybe<Scalars['BigInt']['output']>;
    /** App revision used by an EFFECTIVE projection; zero means missing app policy. */
    appRevision: Scalars['BigInt']['output'];
    /** Allowed modes that cannot do what the mode is for, derived from this layer's own tool and risk allowlists. Read this on the EFFECTIVE projection: an empty list is the only thing that entitles a caller to report an unblocked chain, because "enabled with a null disableReasonCode" is true of a dock whose BUILD mode has no tool it may call. On PLATFORM and APP it describes that layer in isolation and is not a claim about the intersection. */
    capabilityGaps: Array<CrowdyStudioAgentCapabilityGap>;
    /** Policy row creation time or projection time. */
    createdAt: Scalars['DateTime']['output'];
    /** Safe operator/app reason text; never includes provider bodies or secrets. */
    disableReason: Maybe<Scalars['String']['output']>;
    /** Stable disable/kill reason code (for example AGENT_OPERATOR_KILLED); null when enabled. */
    disableReasonCode: Maybe<Scalars['String']['output']>;
    /** Composite Management revision, formatted p<platform revision>:a<app revision>. Game API pins it only after a successful fresh replica pull. */
    effectiveRevision: Scalars['String']['output'];
    /** Whether this Management policy layer/publication is enabled. EFFECTIVE is true only when all required layers are enabled and no kill applies; it does not attest that Game API has synchronized. */
    enabled: Scalars['Boolean']['output'];
    /** Platform-funded pilot/future billing seam. */
    funding: CrowdyStudioAgentFundingPolicy;
    /** Layer kill state. EFFECTIVE is true when platform, operator-app, or app kill is active. */
    killSwitch: Scalars['Boolean']['output'];
    /** PLATFORM, APP, or EFFECTIVE projection. */
    kind: CrowdyStudioAgentPolicyKind;
    /** Operator-only per-app kill state. App policy mutations cannot clear or alter it. */
    operatorKillSwitch: Scalars['Boolean']['output'];
    /** Platform revision used by an EFFECTIVE projection. */
    platformRevision: Scalars['BigInt']['output'];
    /** Per-player UTC-day and concurrency hard limits. */
    playerDayLimits: CrowdyStudioAgentPlayerDayLimits;
    /** Locked provider privacy and private-source controls. */
    privacy: CrowdyStudioAgentPrivacyPolicy;
    /** Redacted-data retention limits. */
    retention: CrowdyStudioAgentRetentionPolicy;
    /** Revision of this stored layer; zero means no app row exists yet. */
    revision: Scalars['BigInt']['output'];
    /** Per-session hard limits. */
    sessionLimits: CrowdyStudioAgentSessionLimits;
    /** Per-turn hard limits. */
    turnLimits: CrowdyStudioAgentTurnLimits;
    /** Last policy change time or projection time. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Whether a policy object is the platform row, app row, or intersection. */
export declare enum CrowdyStudioAgentPolicyKind {
    /** App-owned policy after write-time platform clamping. */
    App = "APP",
    /** Fail-closed intersection of platform, operator-kill, and app policy. */
    Effective = "EFFECTIVE",
    /** Operator-owned platform policy and hard ceilings. */
    Platform = "PLATFORM"
}
/** Closed CrowdyJS/BWF reason vocabulary for synchronous lease and control preemption. */
export declare enum CrowdyStudioAgentPreemptionReason {
    AdmissionChanged = "ADMISSION_CHANGED",
    BudgetFailure = "BUDGET_FAILURE",
    ClientReattached = "CLIENT_REATTACHED",
    ContextChanged = "CONTEXT_CHANGED",
    ControlTargetChanged = "CONTROL_TARGET_CHANGED",
    Death = "DEATH",
    Disconnected = "DISCONNECTED",
    Escape = "ESCAPE",
    HumanEdit = "HUMAN_EDIT",
    HumanInput = "HUMAN_INPUT",
    HumanStop = "HUMAN_STOP",
    LeaseExpired = "LEASE_EXPIRED",
    OperatorKill = "OPERATOR_KILL",
    PermissionChanged = "PERMISSION_CHANGED",
    QuotaFailure = "QUOTA_FAILURE",
    SessionClosed = "SESSION_CLOSED"
}
/** Provider privacy posture. ZDR and collection denial are locked true; provider request/response bodies are never persisted. */
export type CrowdyStudioAgentPrivacyPolicy = {
    __typename?: 'CrowdyStudioAgentPrivacyPolicy';
    /** Whether selected private project source may be sent after the separate human disclosure/consent gate. */
    allowPrivateSource: Scalars['Boolean']['output'];
    /** Whether routed-provider data collection must be denied. Always true in v1. */
    denyDataCollection: Scalars['Boolean']['output'];
    /** Whether provider HTTP request/response bodies can be persisted. Always false in v1. */
    persistProviderBodies: Scalars['Boolean']['output'];
    /** Whether first-use human disclosure/consent is required for private source. Always true in v1. */
    requirePrivateSourceConsent: Scalars['Boolean']['output'];
    /** Whether Zero Data Retention is required. Always true in v1. */
    requireZdr: Scalars['Boolean']['output'];
};
/** App/platform privacy patch. It can disable private-source sharing; ZDR, collection denial, first-use consent, and provider-body non-persistence are locked. */
export type CrowdyStudioAgentPrivacyPolicyInput = {
    /** Allow selected private source only after the separate human disclosure/consent gate. */
    allowPrivateSource?: InputMaybe<Scalars['Boolean']['input']>;
};
/** Retention ceilings for redacted Agentic Studio data. Provider wire bodies, headers, private reasoning, and individual token deltas always have zero retention and are absent. */
export type CrowdyStudioAgentRetentionPolicy = {
    __typename?: 'CrowdyStudioAgentRetentionPolicy';
    /** Coalesced assistant chunk retention in hours (0-24). */
    assistantChunkHours: Scalars['Int']['output'];
    /** Detailed game observation/browser tool-result retention in hours (0-24). */
    detailedContextHours: Scalars['Int']['output'];
    /** Final messages, redacted events, and checkpoint retention after close in days (0-30). */
    sessionDataDays: Scalars['Int']['output'];
    /** Provider generation/token/cost and kill metadata retention in days (1-90). */
    usageDays: Scalars['Int']['output'];
};
/** Retention patch. Values may only shorten the platform policy and the hard pilot maxima. */
export type CrowdyStudioAgentRetentionPolicyInput = {
    /** Coalesced assistant chunk retention in hours (0-24). */
    assistantChunkHours?: InputMaybe<Scalars['Int']['input']>;
    /** Detailed observation/browser result retention in hours (0-24). */
    detailedContextHours?: InputMaybe<Scalars['Int']['input']>;
    /** Final message/redacted event retention after close in days (0-30). */
    sessionDataDays?: InputMaybe<Scalars['Int']['input']>;
    /** Generation/token/cost/kill metadata retention in days (1-90). */
    usageDays?: InputMaybe<Scalars['Int']['input']>;
};
/** Tool risk classes from crowdy.agent-tools/1. App policy may only remove platform-allowed classes; locked approval requirements still apply. */
export declare enum CrowdyStudioAgentRiskClass {
    /** Destructive action; exact human approval required. */
    Destructive = "DESTRUCTIVE",
    /** Money or commerce action; exact human approval required. */
    Economic = "ECONOMIC",
    /** Irreversible action; exact human approval required. */
    Irreversible = "IRREVERSIBLE",
    /** Owner/app-scoped reads with redaction. */
    ReadOnly = "READ_ONLY",
    /** Reversible Build writes with revision checks and checkpoints. */
    RoutineWrite = "ROUTINE_WRITE",
    /** Trust, consent, or capability change; exact human approval required. */
    TrustConsent = "TRUST_CONSENT",
    /** Routine Play actions requiring a visible human-granted lease. */
    WorldControl = "WORLD_CONTROL"
}
/** Serialized durable state of one accepted human message and its provider/tool loop. */
export declare enum CrowdyStudioAgentRunStatus {
    /** Terminal human cancellation. */
    Cancelled = "CANCELLED",
    /** Terminal typed failure; inspect errorCode. */
    Failed = "FAILED",
    /** Recoverable human pause; resume revalidates context. */
    Paused = "PAUSED",
    /** Terminal safety preemption caused by context/control loss. */
    Preempted = "PREEMPTED",
    /** Durably accepted and awaiting a worker claim. */
    Queued = "QUEUED",
    /** Owned by one leased orchestrator worker. */
    Running = "RUNNING",
    /** Finished with a canonical assistant message. */
    Succeeded = "SUCCEEDED",
    /** Waiting for a short-lived exact human decision. */
    WaitingForApproval = "WAITING_FOR_APPROVAL",
    /** Waiting for one matching browser tool result. */
    WaitingForTool = "WAITING_FOR_TOOL"
}
/** Per-session cumulative provider/tool/compile limits and the serialized-run concurrency ceiling. */
export type CrowdyStudioAgentSessionLimits = {
    __typename?: 'CrowdyStudioAgentSessionLimits';
    /** Maximum draft compile submissions in one session. */
    compiles: Scalars['Int']['output'];
    /** Maximum concurrent non-terminal runs in a session. The v1 contract requires one. */
    concurrentRuns: Scalars['Int']['output'];
    /** Maximum input tokens in one session. */
    inputTokens: Scalars['BigInt']['output'];
    /** Maximum output tokens in one session. */
    outputTokens: Scalars['BigInt']['output'];
    /** Maximum provider cost in one session, in micro-USD. */
    providerCostMicrousd: Scalars['BigInt']['output'];
    /** Maximum provider requests in one session. */
    providerRequests: Scalars['Int']['output'];
    /** Maximum reasoning tokens in one session. */
    reasoningTokens: Scalars['BigInt']['output'];
    /** Maximum tool calls in one session. */
    toolCalls: Scalars['Int']['output'];
    /** Maximum total provider tokens in one session. */
    totalTokens: Scalars['BigInt']['output'];
};
/** Patch for per-session limits. Omitted values stay unchanged; supplied values are clamped down to platform ceilings. */
export type CrowdyStudioAgentSessionLimitsInput = {
    /** Maximum draft compile submissions in one session. */
    compiles?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum concurrent non-terminal runs in one session. */
    concurrentRuns?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum input tokens in one session; positive decimal string. */
    inputTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum output tokens in one session; positive decimal string. */
    outputTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum provider cost in one session, in positive micro-USD. */
    providerCostMicrousd?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum provider requests in one session. */
    providerRequests?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum reasoning tokens in one session; positive decimal string. */
    reasoningTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum tool calls in one session. */
    toolCalls?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum total provider tokens in one session. */
    totalTokens?: InputMaybe<Scalars['BigInt']['input']>;
};
/** Durable lifecycle state of an owner/app agent session. */
export declare enum CrowdyStudioAgentSessionStatus {
    /** Accepts human control mutations and one run. */
    Active = "ACTIVE",
    /** Permanently closed, all capabilities revoked, and retention cleanup scheduled. */
    Closed = "CLOSED",
    /** Stopped by the human or reconnect flow; explicit context-revalidating resume is required. */
    Paused = "PAUSED",
    /** Disabled by authoritative policy or platform control and cannot resume. */
    Revoked = "REVOKED"
}
/** Durable state of one descriptor-pinned serialized tool proposal. */
export declare enum CrowdyStudioAgentToolCallStatus {
    /** Cancelled before a known successful effect. */
    Cancelled = "CANCELLED",
    /** Human denied the exact proposal. */
    Denied = "DENIED",
    /** Durably sent to the matching attached browser epoch. */
    Dispatched = "DISPATCHED",
    /** Typed executor failure. */
    Failed = "FAILED",
    /** An effect may have occurred; it is never retried blindly and requires human inspection. */
    OutcomeUnknown = "OUTCOME_UNKNOWN",
    /** Validated and recorded, not yet dispatched. */
    Proposed = "PROPOSED",
    /** Executor began the typed operation. */
    Running = "RUNNING",
    /** Fenced by an epoch or context change. */
    Stale = "STALE",
    /** Typed output validated successfully. */
    Succeeded = "SUCCEEDED",
    /** The recorded tool deadline elapsed. */
    TimedOut = "TIMED_OUT",
    /** Blocked on the exact argument-hash approval. */
    WaitingForApproval = "WAITING_FOR_APPROVAL"
}
/** Trusted boundary that executes a typed tool. */
export declare enum CrowdyStudioAgentToolExecutor {
    /** The attached CrowdyJS host executes once after epoch/context/lease validation. */
    Browser = "BROWSER",
    /** Game API invokes an owner-scoped domain service; never shell or arbitrary GraphQL. */
    Server = "SERVER"
}
/** Terminal result reported once by a browser executor. */
export declare enum CrowdyStudioAgentToolResultStatus {
    /** Known cancelled before successful effect. */
    Cancelled = "CANCELLED",
    /** Effect is known failed with a typed safe error. */
    Failed = "FAILED",
    /** Effect may have happened; server fails the run without retrying. */
    OutcomeUnknown = "OUTCOME_UNKNOWN",
    /** Effect and typed output are known successful. */
    Succeeded = "SUCCEEDED",
    /** Browser deadline elapsed. */
    TimedOut = "TIMED_OUT"
}
/** Server-classified effect risk; app policy may only tighten it. */
export declare enum CrowdyStudioAgentToolRisk {
    /** Possible data/path loss; exact human approval required. */
    Destructive = "DESTRUCTIVE",
    /** Moves or commits value; exact human approval required. */
    Economic = "ECONOMIC",
    /** Cannot be safely undone; exact human approval required. */
    Irreversible = "IRREVERSIBLE",
    /** No canonical state mutation. */
    ReadOnly = "READ_ONLY",
    /** Reversible expected-revision write with checkpointing. */
    RoutineWrite = "ROUTINE_WRITE",
    /** Changes trust or consent; exact human approval required. */
    TrustConsent = "TRUST_CONSENT",
    /** Routine game control requiring an explicit Play scope. */
    WorldControl = "WORLD_CONTROL"
}
/** Per-turn provider/tool/compile limits. Token and cost values are exact decimal BigInt strings; cost is in micro-US-dollars. */
export type CrowdyStudioAgentTurnLimits = {
    __typename?: 'CrowdyStudioAgentTurnLimits';
    /** Maximum draft compile submissions in one turn. */
    compiles: Scalars['Int']['output'];
    /** Maximum concurrent provider requests in one turn. The v1 orchestrator still serializes calls. */
    concurrentProviderRequests: Scalars['Int']['output'];
    /** Maximum input tokens in one turn. */
    inputTokens: Scalars['BigInt']['output'];
    /** Maximum output tokens in one turn. */
    outputTokens: Scalars['BigInt']['output'];
    /** Maximum reserved/reconciled provider cost per turn, in micro-USD. */
    providerCostMicrousd: Scalars['BigInt']['output'];
    /** Maximum provider requests in one accepted turn. */
    providerRequests: Scalars['Int']['output'];
    /** Maximum reasoning tokens in one turn. */
    reasoningTokens: Scalars['BigInt']['output'];
    /** Maximum tool calls in one turn. */
    toolCalls: Scalars['Int']['output'];
    /** Maximum serialized provider/tool rounds in one turn. */
    toolRounds: Scalars['Int']['output'];
    /** Maximum total provider tokens in one turn. */
    totalTokens: Scalars['BigInt']['output'];
    /** Maximum turn wall-clock duration in milliseconds. */
    wallClockMs: Scalars['Int']['output'];
};
/** Patch for per-turn limits. Omitted values stay unchanged; supplied values must be positive and are clamped down to platform ceilings. */
export type CrowdyStudioAgentTurnLimitsInput = {
    /** Maximum draft compile submissions in one turn. */
    compiles?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum concurrent provider requests in one turn. */
    concurrentProviderRequests?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum input tokens in one turn; positive decimal string. */
    inputTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum output tokens in one turn; positive decimal string. */
    outputTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum provider cost in one turn, in positive micro-USD. */
    providerCostMicrousd?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum provider requests in one turn; positive integer. */
    providerRequests?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum reasoning tokens in one turn; positive decimal string. */
    reasoningTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum tool calls in one turn; positive integer. */
    toolCalls?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum serialized provider/tool rounds in one turn. */
    toolRounds?: InputMaybe<Scalars['Int']['input']>;
    /** Maximum total provider tokens in one turn; positive decimal string. */
    totalTokens?: InputMaybe<Scalars['BigInt']['input']>;
    /** Maximum wall-clock duration of one turn in milliseconds. */
    wallClockMs?: InputMaybe<Scalars['Int']['input']>;
};
/** Sanitized app usage read model: newest exact records plus an aggregate for the requested window. */
export type CrowdyStudioAgentUsagePage = {
    __typename?: 'CrowdyStudioAgentUsagePage';
    /** Newest usage records, bounded by the requested limit. */
    records: Array<CrowdyStudioAgentUsageRecord>;
    /** Inclusive start of the usage window. */
    since: Scalars['DateTime']['output'];
    /** Aggregate over the full requested time window, not only returned records. */
    summary: CrowdyStudioAgentUsageSummary;
    /** Exclusive end of the usage window. */
    until: Scalars['DateTime']['output'];
};
/** One sanitized, platform-funded provider usage record. It contains exact OpenRouter token/cost dimensions but no key, prompt, headers, request/response body, private reasoning, or wallet debit. */
export type CrowdyStudioAgentUsageRecord = {
    __typename?: 'CrowdyStudioAgentUsageRecord';
    /** RECONCILED or RESERVATION_CONSUMED when terminal usage was unavailable. */
    accountingStatus: Scalars['String']['output'];
    /** App whose agent run consumed usage. */
    appId: Scalars['BigInt']['output'];
    /** Pinned app policy revision. */
    appPolicyRevision: Scalars['BigInt']['output'];
    /** Funding mode; 'PLATFORM_FUNDED' in the pilot. */
    billingMode: Scalars['String']['output'];
    /** OpenRouter cached token count. */
    cachedTokens: Scalars['BigInt']['output'];
    /** Draft compile submissions in the run. */
    compileCount: Scalars['BigInt']['output'];
    /** OpenRouter completion token count. */
    completionTokens: Scalars['BigInt']['output'];
    /** True: provider data collection was denied. */
    dataCollectionDenied: Scalars['Boolean']['output'];
    /** When Management API accepted the usage record. */
    ingestedAt: Scalars['DateTime']['output'];
    /** Provider-native cached token count. */
    nativeCachedTokens: Scalars['BigInt']['output'];
    /** Provider-native completion token count. */
    nativeCompletionTokens: Scalars['BigInt']['output'];
    /** Provider-native prompt token count. */
    nativePromptTokens: Scalars['BigInt']['output'];
    /** Provider-native reasoning token count. */
    nativeReasoningTokens: Scalars['BigInt']['output'];
    /** When the provider usage occurred. */
    occurredAt: Scalars['DateTime']['output'];
    /** Payer kind; 'PLATFORM' in the pilot. */
    payerKind: Scalars['String']['output'];
    /** Pinned platform policy revision. */
    platformPolicyRevision: Scalars['BigInt']['output'];
    /** OpenRouter prompt token count. */
    promptTokens: Scalars['BigInt']['output'];
    /** Provider name; 'openrouter' for the v1 pilot. */
    provider: Scalars['String']['output'];
    /** Exact provider-reported OpenRouter cost in decimal USD (up to 18 fractional digits). */
    providerCostUsd: Scalars['String']['output'];
    /** Opaque OpenRouter generation id; null when terminal provider accounting was unavailable. */
    providerGenerationId: Maybe<Scalars['String']['output']>;
    /** OpenRouter reasoning token count. */
    reasoningTokens: Scalars['BigInt']['output'];
    /** Provider request count. */
    requestCount: Scalars['BigInt']['output'];
    /** Worst-case cost reserved before provider contact, in micro-USD. */
    reservedCostMicrousd: Scalars['BigInt']['output'];
    /** Resolved allowlisted model id. */
    resolvedModelId: Scalars['String']['output'];
    /** Game-local Agentic Studio run UUID. */
    runId: Scalars['String']['output'];
    /** Game-local Agentic Studio session UUID. */
    sessionId: Scalars['String']['output'];
    /** Validated tool calls in the run. */
    toolCalls: Scalars['BigInt']['output'];
    /** Serialized provider/tool rounds in the run. */
    toolRounds: Scalars['BigInt']['output'];
    /** Exact upstream inference cost in decimal USD when reported. */
    upstreamInferenceCostUsd: Maybe<Scalars['String']['output']>;
    /** Game API-issued immutable usage UUID. */
    usageId: Scalars['String']['output'];
    /** Player whose isolated budget consumed usage. */
    userId: Scalars['BigInt']['output'];
    /** Accepted run wall-clock duration in milliseconds, from durable run start to finish. */
    wallClockMs: Scalars['BigInt']['output'];
    /** True: OpenRouter ZDR was enforced. */
    zdrEnforced: Scalars['Boolean']['output'];
};
/** Exact aggregate over the returned app/window usage records. Decimal USD remains a string to preserve precision. */
export type CrowdyStudioAgentUsageSummary = {
    __typename?: 'CrowdyStudioAgentUsageSummary';
    /** Cached tokens. */
    cachedTokens: Scalars['BigInt']['output'];
    /** Draft compiles. */
    compileCount: Scalars['BigInt']['output'];
    /** Completion tokens. */
    completionTokens: Scalars['BigInt']['output'];
    /** Prompt tokens. */
    promptTokens: Scalars['BigInt']['output'];
    /** Exact summed provider cost in decimal USD. */
    providerCostUsd: Scalars['String']['output'];
    /** Reasoning tokens. */
    reasoningTokens: Scalars['BigInt']['output'];
    /** Provider requests. */
    requestCount: Scalars['BigInt']['output'];
    /** Tool calls. */
    toolCalls: Scalars['BigInt']['output'];
    /** Tool rounds. */
    toolRounds: Scalars['BigInt']['output'];
    /** Summed accepted-run wall-clock milliseconds. */
    wallClockMs: Scalars['BigInt']['output'];
};
/** A Crowdy Studio-curated app-scoped common file at its current immutable published version. Unlike personal source, this content is intentionally readable by app-scoped players. */
export type CrowdyStudioCommonFile = {
    __typename?: 'CrowdyStudioCommonFile';
    /** App tenant whose players may read this published entry. */
    appId: Scalars['BigInt']['output'];
    /** Stable common catalog entry UUID. */
    commonFileId: Scalars['String']['output'];
    /** Published UTF-8 source text for this immutable version. */
    content: Scalars['String']['output'];
    /** Lowercase SHA-256 digest of the exact UTF-8 content bytes. */
    contentSha256: Scalars['String']['output'];
    /** Catalog entry creation timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional Crowdy Studio-authored catalog description. */
    description: Maybe<Scalars['String']['output']>;
    /** Safe recommended project destination path. */
    path: Scalars['String']['output'];
    /** Timestamp when the current immutable version was published. */
    publishedAt: Scalars['DateTime']['output'];
    /** Crowdy Studio user that published the current immutable version. */
    publishedByUserId: Scalars['BigInt']['output'];
    /** Stable lowercase URL-safe catalog slug. */
    slug: Scalars['String']['output'];
    /** Catalog lifecycle state; ordinary player queries expose only PUBLISHED. */
    status: CrowdyStudioCommonStatus;
    /** Normalized Crowdy Studio-curated discovery tags. */
    tags: Array<Scalars['String']['output']>;
    /** Compatible project target for this catalog entry. */
    target: CrowdyStudioTarget;
    /** Crowdy Studio-authored catalog title. */
    title: Scalars['String']['output'];
    /** Timestamp of the latest catalog publication. */
    updatedAt: Scalars['DateTime']['output'];
    /** Current immutable content-version UUID. */
    versionId: Scalars['String']['output'];
    /** Monotonic immutable version number within the catalog entry. */
    versionNo: Scalars['BigInt']['output'];
};
/** Crowdy Studio catalog visibility. Player catalog queries return only published entries. */
export declare enum CrowdyStudioCommonStatus {
    /** Retained for provenance but hidden from new player catalog reads and imports. */
    Archived = "ARCHIVED",
    /** Crowdy Studio work in progress; hidden from player common-file queries. */
    Draft = "DRAFT",
    /** Available to app-scoped players for reading and copy-by-value import. */
    Published = "PUBLISHED"
}
/** How a project file entered the project. Imported content is copied by value; provenance is informational and does not create a live link. */
export declare enum CrowdyStudioFileProvenance {
    /** The owner authored or directly saved this project file. */
    Authored = "AUTHORED",
    /** The file was copied from a specific immutable version of the app’s Crowdy Studio-curated common catalog. */
    Common = "COMMON",
    /** The file was copied from a specific revision of the owner’s private personal library. */
    Library = "LIBRARY"
}
/** The source catalog used for a copy-by-value project file import. */
export declare enum CrowdyStudioImportSource {
    /** Import from an immutable published common-file version in the requested app. */
    Common = "COMMON",
    /** Import from a private personal-library file owned by the authenticated caller. */
    Library = "LIBRARY"
}
/** A reusable private text file in the authenticated player’s app-scoped personal library. */
export type CrowdyStudioLibraryFile = {
    __typename?: 'CrowdyStudioLibraryFile';
    /** App tenant that isolates this private library entry. */
    appId: Scalars['BigInt']['output'];
    /** Whether this entry is archived and unavailable for new imports. */
    archived: Scalars['Boolean']['output'];
    /** Archive timestamp, or null while active. */
    archivedAt: Maybe<Scalars['DateTime']['output']>;
    /** Private UTF-8 source text, visible only to the app-scoped owner. */
    content: Scalars['String']['output'];
    /** Library entry creation timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Stable personal-library file UUID. */
    libraryFileId: Scalars['String']['output'];
    /** User that exclusively owns this library entry. */
    ownerUserId: Scalars['BigInt']['output'];
    /** Safe suggested destination path; imports may choose another safe path. */
    pathHint: Scalars['String']['output'];
    /** Monotonic optimistic-concurrency revision. */
    revision: Scalars['BigInt']['output'];
    /** Normalized search tags, each lowercase and hyphen-safe. */
    tags: Array<Scalars['String']['output']>;
    /** Compatible project target for this reusable file. */
    target: CrowdyStudioTarget;
    /** Player-facing library title. */
    title: Scalars['String']['output'];
    /** Timestamp of the latest successful library mutation. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Editor preference describing how the project presents its server and client targets; it never grants deployment or runtime authority. */
export declare enum CrowdyStudioPairingPreference {
    /** Present only the client-target authoring workflow. */
    ClientOnly = "CLIENT_ONLY",
    /** Present server and client sources independently without an implied requirement edge. */
    Independent = "INDEPENDENT",
    /** Present server and client sources as two coordinated halves of one Crowdy Studio project. */
    Paired = "PAIRED",
    /** Present only the server-target authoring workflow. */
    ServerOnly = "SERVER_ONLY"
}
/** A private, revisioned Crowdy Studio project owned by one user in one app. Optional grid affinity and module names are authoring hints only; deployment still rechecks current grid ownership and target-specific permissions. */
export type CrowdyStudioProject = {
    __typename?: 'CrowdyStudioProject';
    /** Pinned guest ABI version used when constructing deploy input. */
    abiVersion: Scalars['Int']['output'];
    /** App tenant that isolates this project and all of its source. */
    appId: Scalars['BigInt']['output'];
    /** Whether the project is archived. Archived projects remain private and retained but are read-only until unarchived. */
    archived: Scalars['Boolean']['output'];
    /** Archive timestamp, or null while the project is active. */
    archivedAt: Maybe<Scalars['DateTime']['output']>;
    /** Stable crate-style CLIENT module name used when the owner chooses to deploy, or null when unassigned. */
    clientModuleName: Maybe<Scalars['String']['output']>;
    /** Project creation timestamp. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional private project description. */
    description: Maybe<Scalars['String']['output']>;
    /** Total file count across both targets; each target is independently capped at eight. */
    fileCount: Scalars['Int']['output'];
    /** Private project files ordered by target and path. Bounded to eight files per target. */
    files: Array<CrowdyStudioProjectFile>;
    /** Optional grid affinity. It survives a grid transfer and does not itself grant deploy authority. */
    gridId: Maybe<Scalars['BigInt']['output']>;
    /** Player-facing project name. */
    name: Scalars['String']['output'];
    /** User that exclusively owns and may read or modify this project source. */
    ownerUserId: Scalars['BigInt']['output'];
    /** Editor presentation preference for the two source targets. */
    pairingPreference: CrowdyStudioPairingPreference;
    /** Stable project UUID. */
    projectId: Scalars['String']['output'];
    /** Monotonic project revision required by optimistic metadata, file, import, and archive mutations. */
    revision: Scalars['BigInt']['output'];
    /** Pinned crowdy-compute-sdk version used when constructing deploy input. */
    sdkVersion: Scalars['String']['output'];
    /** Stable crate-style SERVER module name used when the owner chooses to deploy, or null when unassigned. */
    serverModuleName: Maybe<Scalars['String']['output']>;
    /** Total UTF-8 source bytes across both targets, bounded by target and aggregate owner quotas. */
    totalBytes: Scalars['BigInt']['output'];
    /** Timestamp of the latest successful project mutation. */
    updatedAt: Scalars['DateTime']['output'];
};
/** One private text file in a player-owned project. It is returned only when both app id and authenticated owner match the project. */
export type CrowdyStudioProjectFile = {
    __typename?: 'CrowdyStudioProjectFile';
    /** Private UTF-8 source text. Grid ownership and Crowdy Studio permissions never override project ownership. */
    content: Scalars['String']['output'];
    /** Timestamp when this target/path entry was first created. */
    createdAt: Scalars['DateTime']['output'];
    /** Safe compute-source relative path: Cargo.toml or a Rust file below src/. */
    path: Scalars['String']['output'];
    /** Copy provenance. Imported bytes remain unchanged if the source catalog entry later changes. */
    provenance: CrowdyStudioFileProvenance;
    /** Immutable common-file version UUID copied into this file, or null when common provenance does not apply. */
    provenanceCommonVersionId: Maybe<Scalars['String']['output']>;
    /** Private library file UUID used for the copy, or null for authored/common content. */
    provenanceLibraryFileId: Maybe<Scalars['String']['output']>;
    /** Library revision copied into this file, or null when library provenance does not apply. */
    provenanceLibraryRevision: Maybe<Scalars['BigInt']['output']>;
    /** Monotonic revision of this target/path entry, incremented on every successful upsert. */
    revision: Scalars['BigInt']['output'];
    /** Server or client target whose independent 8-file/256-KiB deploy cap includes this file. */
    target: CrowdyStudioTarget;
    /** Timestamp of the latest successful content/provenance save. */
    updatedAt: Scalars['DateTime']['output'];
};
/** A target/path key removed atomically by crowdyStudioProjectSaveFiles. */
export type CrowdyStudioProjectFileDeleteInput = {
    /** Safe relative path of the file to remove. */
    path: Scalars['String']['input'];
    /** Project target containing the file to remove. */
    target: CrowdyStudioTarget;
};
/** One direct-authored initial or batch-upsert project file. Paths and UTF-8 bytes are validated against player-compute safety limits. */
export type CrowdyStudioProjectFileInput = {
    /** UTF-8 source text, capped at 64 KiB. */
    content: Scalars['String']['input'];
    /** Safe relative path: Cargo.toml or a .rs file below src/, with no traversal segments. */
    path: Scalars['String']['input'];
    /** Project target receiving this file. */
    target: CrowdyStudioTarget;
};
/** The independently capped source target inside a player-owned Crowdy Studio project. */
export declare enum CrowdyStudioTarget {
    /** Browser-worker Rust that can run only after the caller separately passes current grid ownership and write_client_code deployment checks. */
    Client = "CLIENT",
    /** Server-target Rust that can run only after the caller separately passes current grid ownership and write_server_code deployment checks. */
    Server = "SERVER"
}
/** Whether a datacenter currently has a ck-api instance able to serve clients. Three-valued on purpose: "nothing is serving there" and "the liveness signal could not be read" look identical through a boolean and call for opposite reactions. */
export declare enum DatacenterServingStatus {
    /** The signal was readable and reported no instance able to take a client there. An app placed here would be created and stored correctly, and its players would be told the app is temporarily offline until an instance returns. */
    NotServing = "NOT_SERVING",
    /** At least one instance in that datacenter has heartbeated within the freshness window and is not draining. */
    Serving = "SERVING",
    /** The liveness signal itself could not be read or trusted. Must NOT be presented as an outage: a fleet-wide heartbeat failure once made every datacenter look dead while all of them were fine, and healthy players were told their app was offline. */
    Unknown = "UNKNOWN"
}
/** Approve or reject one exact pending tool call by its displayed argument hash. */
export type DecideAgentToolInput = {
    /** Exact sha256 hash displayed by APPROVAL_REQUESTED; substitutions and stale contexts fail. */
    argumentHash: Scalars['String']['input'];
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Optional bounded human rejection reason. */
    reason?: InputMaybe<Scalars['String']['input']>;
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
    /** Pending tool call UUID. */
    toolCallId: Scalars['String']['input'];
};
/** Define an app feature key. */
export type DefineAppFeatureInput = {
    /** The app (tenant) defining the feature. */
    appId: Scalars['BigInt']['input'];
    /** Optional description of the feature. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** The feature key (referenced by tier_feature authority rules). */
    featureKey: Scalars['String']['input'];
};
/** Identifies a studio-created grid to delete. The default open-by-default world grid and grids that still contain nested child grids cannot be removed. */
export type DeleteGridInput = {
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['input'];
    /** The grid to delete. */
    gridId: Scalars['BigInt']['input'];
};
/** Result of deleteGrid. This is a hybrid result rather than a thrown error: inspect `error` first. When `error` is NO_ERROR the call succeeded and `gridId` is populated; otherwise `gridId` is null and `error` explains why. */
export type DeleteGridResponse = {
    __typename?: 'DeleteGridResponse';
    /** A UDP-style error code (the same ErrorType enum the realtime/UDP servers use). NO_ERROR (0) means success; non-zero values describe the failure, e.g. GRID_NOT_FOUND, CANNOT_DELETE_DEFAULT_WORLD_GRID, GRID_HAS_NESTED_CHILDREN, or UNKNOWN_ERROR. */
    error: UdpErrorCode;
    /** The deleted grid id on success; null when `error` is non-zero. */
    gridId: Maybe<Scalars['BigInt']['output']>;
};
/** Upload a new immutable source version of a module. The source is validated (size caps, crate allowlist, no build-time code) and parked as compile_status=pending until an instance compiles it. */
export type DeployComputeVersionInput = {
    /** The guest ABI version the source targets (must be platform-supported; currently 0). */
    abiVersion: Scalars['Int']['input'];
    /** The app (tenant) that owns the module. */
    appId: Scalars['BigInt']['input'];
    /** The module (by name) this version belongs to. */
    moduleName: Scalars['String']['input'];
    /** The crowdy-compute-sdk version the source targets (must be a platform-supported version, e.g. '0.0.1'). */
    sdkVersion: Scalars['String']['input'];
    /** JSON object mapping relative paths to file contents. Must include Cargo.toml and src/lib.rs; only .rs files under src/ plus Cargo.toml are allowed. Dependencies are restricted to the platform crate allowlist; build.rs and [build-dependencies] are rejected. */
    sourceFilesJson: Scalars['String']['input'];
};
export type DeployPlayerComputeInput = {
    /** Guest ABI version. P1 supports ABI 0. */
    abiVersion?: InputMaybe<Scalars['Int']['input']>;
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Optional player-facing module description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Deploy in draft mode (live-coding iteration): the module runs for its author but its spatial egress is suppressed server-side, so no other session in the grid observes its world effects. Omit or false for a normal deploy. */
    draft?: InputMaybe<Scalars['Boolean']['input']>;
    /** Owned grid that confines server execution. */
    gridId: Scalars['BigInt']['input'];
    /** Lowercase crate-style module name, unique within the grid. */
    name: Scalars['String']['input'];
    /** Pinned crowdy-compute-sdk version. Defaults to 0.1.5. */
    sdkVersion?: InputMaybe<Scalars['String']['input']>;
    /** JSON object mapping Cargo.toml and src/*.rs relative paths to source. P1 player caps: at most 8 files, 64 KiB/file, 256 KiB total. */
    sourceFilesJson: Scalars['String']['input'];
    /** SERVER or CLIENT compile target. */
    target: PlayerComputeTarget;
    /** Optional server tick rate in Hz. Omit for invoke/event-only modules or CLIENT artifacts. Clamped by the effective player/app policy. */
    tickHz?: InputMaybe<Scalars['Float']['input']>;
};
/** Everything this API knows about whether an address can be emailed, and why. */
export type EmailDeliverability = {
    __typename?: 'EmailDeliverability';
    email: Scalars['String']['output'];
    /** Most recent events first. */
    events: Array<EmailEventRecord>;
    /** Whether a send to this address would be attempted right now. False for a permanent bounce, a complaint, or a transient bounce inside its 24-hour cool-off. */
    sendable: Scalars['Boolean']['output'];
    /** Null means SES has never reported anything about this address, which is treated as sendable. */
    status: Maybe<EmailStatusRecord>;
    /** Whether this address is refused before SES is consulted at all, because its domain is in EMAIL_SUPPRESS_DOMAINS. */
    suppressedDomain: Scalars['Boolean']['output'];
};
/** How this API instance is configured to send mail. Read it before concluding that a missing email is a bug: an instance with sendingEnabled=false composes every message and hands none of them to SES. */
export type EmailDeliveryConfig = {
    __typename?: 'EmailDeliveryConfig';
    /** SES_CONFIGURATION_SET. Null or empty means sends carry no configuration set, so SES publishes NO delivery or bounce events for them and this tier learns nothing about its own mail. */
    configurationSet: Maybe<Scalars['String']['output']>;
    /** The From address (EMAIL_FROM). */
    fromAddress: Scalars['String']['output'];
    /** AWS_REGION used for SES. */
    region: Scalars['String']['output'];
    /** SEND_EMAILS. False means nothing reaches SES from this instance. */
    sendingEnabled: Scalars['Boolean']['output'];
    /** Domain suffixes refused before SES is consulted (EMAIL_SUPPRESS_DOMAINS). */
    suppressedDomains: Array<Scalars['String']['output']>;
};
/** One recorded SES event for an address: the `send` this API wrote when it handed the message to SES, or a `delivery` / `bounce` / `complaint` / `delivery_delay` that arrived back on the SNS webhook. */
export type EmailEventRecord = {
    __typename?: 'EmailEventRecord';
    /** When the row was written (ISO 8601). */
    createdAt: Scalars['String']['output'];
    /** Recipient address the event concerns. */
    email: Scalars['String']['output'];
    /** Event detail where SES supplies one: `Permanent/General` for a bounce, the complaint feedback type for a complaint. */
    eventSubtype: Maybe<Scalars['String']['output']>;
    /** send | delivery | bounce | complaint | delivery_delay. Lower-case, as stored. */
    eventType: Scalars['String']['output'];
    /** SES message id. Present on the `send` row this API writes and on the feedback events SES publishes for it, which is what lets one send be matched to its own delivery rather than a previous run's. */
    messageId: Maybe<Scalars['String']['output']>;
};
/** An address's stored deliverability record. Absent (null) until SES reports something about the address. */
export type EmailStatusRecord = {
    __typename?: 'EmailStatusRecord';
    bounceSubType: Maybe<Scalars['String']['output']>;
    /** Permanent | Transient | Undetermined, from SES. */
    bounceType: Maybe<Scalars['String']['output']>;
    complaintType: Maybe<Scalars['String']['output']>;
    deliveryAttempts: Maybe<Scalars['Int']['output']>;
    email: Scalars['String']['output'];
    /** True once SES has reported a permanent bounce or a complaint. This is what stops the address being sent to again. */
    isPermanentFailure: Maybe<Scalars['Boolean']['output']>;
    lastEventAt: Maybe<Scalars['String']['output']>;
    lastEventType: Maybe<Scalars['String']['output']>;
    messageId: Maybe<Scalars['String']['output']>;
    /** valid | bounced | complained. */
    status: Scalars['String']['output'];
};
/** Compute units attributed to one engine over the query window. */
export type EngineComputeUnits = {
    __typename?: 'EngineComputeUnits';
    /** The engine whose meter produced these units. */
    engine: MeteredComputeEngine;
    /** Compute units, where one unit is one millisecond of measured execution time. Comparable across engines by construction: both engines measure the same quantity with the same clock (process.hrtime around the app's code), and a WASM engine additionally floors its answer by fuel/22,000,000 to charge work done inside the sandbox between two host calls. Zero when the engine ran nothing. */
    units: Scalars['BigInt']['output'];
};
/** Atomically get-or-create a container by an opaque binding key. The key is unique per (appId, typeName, sessionId); concurrent ensures converge on one row. Creation-only fields are ignored when the row already exists. */
export type EnsureContainerInput = {
    /** The app (tenant) the container belongs to. */
    appId: Scalars['BigInt']['input'];
    /** Opaque client-derived key (max 128 chars) identifying the shared container within (appId, typeName, sessionId). All concurrent ensures with the same key return the same containerId. */
    bindingKey: Scalars['String']['input'];
    /** Optional description. Used ONLY when this call creates the row. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Human-friendly display name. Used ONLY when this call creates the row. */
    displayName: Scalars['String']['input'];
    /** JSON object of metadata. Used ONLY when this call creates the row. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** Owner user id, same rules as CreateContainerInput (defaults to the caller for member/owner types, shared null for admin types). Used ONLY when this call creates the row. */
    ownerUserId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Initial property values. Used ONLY when this call creates the row. */
    properties?: InputMaybe<Array<SeedPropertyInput>>;
    /** Optional session scoping the key and the container (omit for app-global). Two sessions may hold the same bindingKey independently. */
    sessionId?: InputMaybe<Scalars['String']['input']>;
    /** The container type to resolve or instantiate. */
    typeName: Scalars['String']['input'];
};
/** Input for exchangePortalCode: the destination game (public client) trades a one-time portal code for an app-scoped gameplay token. Public (the code + PKCE verifier authorize the call). */
export type ExchangePortalCodeInput = {
    /** The one-time authorization code received on the redirect. */
    code: Scalars['String']['input'];
    /** PKCE code verifier matching the challenge supplied when the code was created. Required when the code was created with a challenge. */
    codeVerifier?: InputMaybe<Scalars['String']['input']>;
};
/** 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). */
    paidApps: Scalars['Int']['output'];
    /** Total free shared app slots granted to the org. */
    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'];
};
export type FreePlayWindowInfo = {
    __typename?: 'FreePlayWindowInfo';
    /** Human-readable description of the free-play schedule. */
    description: Scalars['String']['output'];
    /** True if a free-play window is active right now. */
    isCurrentlyActive: Scalars['Boolean']['output'];
    /** ISO-8601 start time of the next free-play window, or null if none. */
    nextWindowStart: Maybe<Scalars['String']['output']>;
};
/** One property write a function performs. */
export type FunctionMutationInput = {
    /** Expression string (compiled to AST server-side). */
    expression: Scalars['String']['input'];
    /** The property key to write. */
    property: Scalars['String']['input'];
    /** Container target: self | ref("uuid") | ref($param). */
    target: Scalars['String']['input'];
};
/** A declarative realtime notification the function emits via Buddy AFTER its transaction commits. Players and automations (NPCs) emit identically. Fenced by delivery mode (proximity / channel membership / target). */
export type FunctionNotificationInput = {
    /** Named argument expressions. spatial: chunk_x/chunk_y/chunk_z required (+ event_type/state/distance/decay/source_uuid); channel: channel_id/payload required (+ sender_uuid); actor: target_uuid/payload required (+ chunk_x/y/z/source_uuid). */
    args: Array<NotificationArgInput>;
    /** For kind 'spatial': which client downlink Buddy emits — 'server_event' (default) | 'generic_spatial' | 'actor_update'. */
    emitAs?: InputMaybe<Scalars['String']['input']>;
    /** Delivery mode: 'spatial' (nearby clients) | 'channel' (channel members) | 'actor' (one target). */
    kind: Scalars['String']['input'];
};
/** A typed parameter declaration for a function. */
export type FunctionParamInput = {
    /** JSON-encoded default value. */
    defaultValueJson?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the parameter. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Parameter name (referenced as $name in expressions). */
    name: Scalars['String']['input'];
    /** Whether the parameter is required. Defaults to true. */
    required?: InputMaybe<Scalars['Boolean']['input']>;
    /** Display/order index. Defaults to 0. */
    sortOrder?: InputMaybe<Scalars['Int']['input']>;
    /** int | float | string | bool | array | object | container_ref */
    valueType: Scalars['String']['input'];
};
/** A declarative grid-permission effect the function applies TRANSACTIONALLY with its property mutations: grant or revoke runtime grid permissions (the same ACL Buddy enforces on movement/voxel writes) driven by game logic. Expressions are compiled server-side and evaluated in the invocation context (params plus the injected $caller_user_id / $self_owner_id / $session_id / $current_turn_user_id / $self_container_id). If an effect fails, the whole invocation rolls back. Applied effects are recorded on the invocation event. */
export type FunctionPermissionEffectInput = {
    /** 'grant' (upsert direct grants, optionally expiring) or 'revoke' (delete direct grants for the listed keys). */
    action: Scalars['String']['input'];
    /** Expression resolving the grid id (int) the permissions apply to, e.g. "self.grid_id". The grid must belong to the app. */
    gridIdExpression: Scalars['String']['input'];
    /** Runtime permission keys to grant/revoke (validated against the runtime_permissions catalog, e.g. 'access', 'teleport', 'update_voxel_data', 'use_voice_chat'). */
    permissionKeys: Array<Scalars['String']['input']>;
    /** Grant only: optional expression resolving a TTL in seconds (int > 0) after which the grant expires (rentals/leases), e.g. '86400'. Omit for a non-expiring grant. */
    ttlSecondsExpression?: InputMaybe<Scalars['String']['input']>;
    /** Expression resolving the target user id (int), e.g. "$caller_user_id" or "self.owner_user_id". */
    userExpression: Scalars['String']['input'];
};
/** A declarative one-shot timer the function arms TRANSACTIONALLY with its property mutations: "invoke this function again in N ms". The timer survives replica restarts and is claimed by the same dispatcher that runs scheduled automations, so it fires exactly once. Rolling back the invocation arms nothing. The target function must be autonomousInvocable, because a timer fires headlessly with no player in the request. */
export type FunctionTimerInput = {
    /** Optional expression resolving an app-scoped string key. Re-arming the same key replaces the pending timer instead of queueing another fire, so a repeatedly invoked function cannot flood the timer queue. */
    dedupeKeyExpression?: InputMaybe<Scalars['String']['input']>;
    /** Expression resolving the delay in milliseconds (int > 0), floored by the app's minTimerDelayMs policy. */
    delayMsExpression: Scalars['String']['input'];
    /** The function to invoke when the timer fires. Must exist and be autonomousInvocable. */
    functionName: Scalars['String']['input'];
    /** Parameters bound into the delayed invocation. Expressions are evaluated at arm time on post-mutation state, so the fired invocation sees the values the arming logic decided. */
    params?: InputMaybe<Array<TimerParamInput>>;
    /** Container reference the delayed invocation runs against, e.g. "self" (default) or "$target_id". */
    target?: InputMaybe<Scalars['String']['input']>;
};
/** Startup contract for browser game clients. Fetch this after login to initialize protocol/version checks and UDP proxy state in one round trip. */
export type GameClientBootstrap = {
    __typename?: 'GameClientBootstrap';
    /** The app (game) this bootstrap was requested for, echoed back. A BigInt as a decimal string. Reuse this exact appId to scope the udpNotifications subscription and on every spatial send for this play session. */
    appId: Scalars['BigInt']['output'];
    /** Whether this server exposes the binary realtime relay (crowdy-relay-v1): a raw WebSocket endpoint at binaryRelayPath that relays complete client-signed Buddy wire datagrams as BINARY frames in both directions, replacing the GraphQL send*\/udpNotifications hot path. When false, use the GraphQL realtime surface. */
    binaryRelayEnabled: Scalars['Boolean']['output'];
    /** HTTP path of the binary realtime relay WebSocket endpoint on this origin (e.g. "/realtime"). Connect with `?appId=<appId>` and offer the binaryRelayProtocol subprotocol; authenticate with an app-scoped bearer token via the Authorization header, a `bearer.<base64url(token)>` subprotocol entry, or `?token=`. Wire format: cks docs, client-wire-formats. */
    binaryRelayPath: Scalars['String']['output'];
    /** Required WebSocket subprotocol for the binary realtime relay. The client must offer it during the upgrade; the server selects it. Currently "crowdy-relay-v1". */
    binaryRelayProtocol: Scalars['String']['output'];
    /** Stable entry point that always resolves to SOME healthy API instance — the environment’s shared load balancer. Use this to RE-DISCOVER an endpoint when the instance you are connected to stops answering: call gameClientBootstrap (or mintAppToken) against it and use the gameApiUrl it returns. This is the recovery path for direct connect, where gameApiUrl is a single instance that can die; discoveryUrl is chosen so that it cannot die with it. Null only if the server has no public URL configured. */
    discoveryUrl: Maybe<Scalars['String']['output']>;
    /** HTTPS origin the client should use for GraphQL right now: the app's OWN datacenter, because that is where its shards live and a query answered elsewhere crosses a WAN silently. Under direct connect it is one specific instance in that datacenter, which is NOT interchangeable with other instances for an open realtime session. Not to be confused with discoveryUrl, which is the shared origin resolving to every datacenter — fall back to that if requests here start failing. */
    gameApiUrl: Maybe<Scalars['String']['output']>;
    /** The wss:// form of gameApiUrl, for the graphql-transport-ws subscription socket and the binary relay. Same origin, same caveat: under direct connect it is one instance. */
    gameApiWsUrl: Maybe<Scalars['String']['output']>;
    /** Maximum allowed value for the `decayRate` (named attenuation algorithm id) field on spatial sends. Currently 5; the server clamps send `decayRate` to 0..this. decayRate selects how the message attenuates with distance (0 = none). */
    maxDecayRate: Scalars['Int']['output'];
    /** Maximum allowed value for the `distance` (chunk fan-out radius) field on spatial sends. Currently 8; the server clamps send `distance` to 0..this. distance is the number of chunks outward the message is replicated. */
    maxReplicationDistance: Scalars['Int']['output'];
    /** The authenticated user resolved from the bearer game token on the request. Use this for the local player identity instead of a separate `me` call. */
    me: User;
    /** GraphQL WebSocket subprotocol expected by udpNotifications. */
    realtimeProtocol: Scalars['String']['output'];
    /** The modulus the per-message sequenceNumber wraps at (256), i.e. sequenceNumber is a uint8 in 0-255. sequenceNumber exists ONLY to correlate asynchronous responses/errors (delivered on udpNotifications) with the send that produced them — it is NOT an idempotency key, and the server does not dedupe replays. */
    sequenceNumberModulo: Scalars['Int']['output'];
    /** GraphQL subscription field that carries UDP proxy notifications. */
    subscriptionName: Scalars['String']['output'];
    /** UDP proxy session status for this game token at bootstrap time. connected is false until you open a session (via connectUdpProxy, any send* mutation, or subscribing to udpNotifications); fetching the bootstrap does not open one. */
    udpProxyConnectionStatus: UdpProxyConnectionStatus;
    /** Current server version and the minimum client version the server accepts. Compare your build against minimumClientVersion before connecting; prompt the player to update if it is too old. */
    versionInfo: ServerVersionInfo;
};
/** The elected host user of a game (app). Election is deterministic across all game-api replicas: among actors that are still fresh (recently heartbeated), the user whose earliest actor was created first wins, with a uuid tiebreaker. Row lifecycle is owned by Buddy, the realtime runtime; liveness (updated_at) is owned by game-api's actorHeartbeat mutation. */
export type GameHost = {
    __typename?: 'GameHost';
    /** How many actors the host user currently owns in this app (always >= 1 when this object is returned). */
    actorCount: Scalars['Int']['output'];
    /** Timestamp of the host's earliest still-connected actor (`MIN(actors.created_at)` for the host's group). Used as the primary election ordering key. */
    earliestActorJoinedAt: Scalars['DateTime']['output'];
    /** The user_id of the elected host. Stable while this user has at least one fresh row in `actors` for the app; the next-oldest user takes over automatically once the current host stops heartbeating (its rows age past HOST_ACTOR_FRESHNESS_SECONDS) or Buddy idle-evicts its last row. */
    hostUserId: Scalars['BigInt']['output'];
};
/** One durable transition between complete app-scoped active gameplay-session counts. Delivery is cross-replica but best-effort; deduplicate by revision and requery gameModelActivePlayerCount after reconnect or a revision gap. */
export type GameModelActivePlayerCountChange = {
    __typename?: 'GameModelActivePlayerCountChange';
    /** The app whose complete active-session count changed. */
    appId: Scalars['BigInt']['output'];
    /** New complete active gameplay-session count after this transition. */
    currentCount: Scalars['Int']['output'];
    /** Signed change: currentCount minus previousCount. */
    delta: Scalars['Int']['output'];
    /** Latest fresh Buddy heartbeat represented by the new count. */
    observedAt: Scalars['DateTime']['output'];
    /** Last complete active gameplay-session count before this transition. */
    previousCount: Scalars['Int']['output'];
    /** Durable monotonic app revision for this transition. Use it to deduplicate and detect gaps. */
    revision: Scalars['BigInt']['output'];
};
/** A point-in-time app-scoped count of active gameplay sessions. This counts sessions, not actors or distinct users; one user with multiple active sessions contributes multiple players. Status states whether the fleet-wide count is complete. */
export type GameModelActivePlayerCountSnapshot = {
    __typename?: 'GameModelActivePlayerCountSnapshot';
    /** Active gameplay sessions currently reported for the app. For PARTIAL this is the best-known sum from supported fresh Buddies; for UNAVAILABLE it is zero because no live report can be observed. Check status before treating it as a complete fleet total. */
    activePlayerCount: Scalars['Int']['output'];
    /** The app whose active gameplay sessions were counted. */
    appId: Scalars['BigInt']['output'];
    /** Latest heartbeat time represented by this observation, or null when no fresh Buddy is available. */
    observedAt: Maybe<Scalars['DateTime']['output']>;
    /** Durable monotonic revision of complete count changes. Zero means the app is untracked or has not changed after its silent baseline. Partial and unavailable observations never advance it. */
    revision: Scalars['BigInt']['output'];
    /** Whether activePlayerCount is complete (FRESH), a supported-Buddy subset (PARTIAL), or unavailable because no Buddy heartbeat is fresh (UNAVAILABLE). */
    status: GameModelPlayerCountStatus;
};
/** Relay-style cursor-paginated connection over the function-invocation event log (GmEvent). Page with `first`/`after`; cursors are opaque. */
export type GameModelEventsConnection = {
    __typename?: 'GameModelEventsConnection';
    /** Edges on this page. */
    edges: Array<GmEventEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** Completeness of an app-scoped active gameplay-session count across the fresh Buddy fleet. */
export declare enum GameModelPlayerCountStatus {
    /** At least one non-Offline Buddy heartbeat is fresh and every fresh Buddy supports version 1 app-scoped counts. The count is complete. */
    Fresh = "FRESH",
    /** At least one non-Offline Buddy heartbeat is fresh, but one or more fresh Buddies do not support app-scoped counts. The count is only the best-known supported-Buddy sum and does not advance change revisions. */
    Partial = "PARTIAL",
    /** No non-Offline Buddy heartbeat is fresh enough to observe. The count is unavailable and does not advance change revisions. */
    Unavailable = "UNAVAILABLE"
}
/** Asynchronous error from the UDP game server for a previously sent datagram (e.g. a send* mutation). Delivered as a member of the udpNotifications union, NOT as a GraphQL error on the mutation (which only reports whether the datagram was accepted for sending). Match it to the originating send via sequenceNumber and read errorCode for the reason. Note: not every failure produces one — some auth failures are dropped silently (see UdpErrorCode). */
export type GenericErrorResponse = {
    __typename?: 'GenericErrorResponse';
    /** Error code indicating the reason for the failure. */
    errorCode: UdpErrorCode;
    /** Echoes the sequenceNumber of the request that failed (a uint8, 0-255, wrapping at modulo 256) so you can correlate this error with the send* mutation that produced it. Correlation only — it is not an idempotency key. */
    sequenceNumber: Scalars['Int']['output'];
};
/** Arguments for getChunk: selects a single chunk by app id and chunk coordinates, with optional LOD filtering. */
export type GetChunkInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk to fetch. */
    coordinates: ChunkCoordinatesInput;
    /** When true, return all available LODs and ignore `requestedLodLevels`. */
    includeAllLods?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional list of LOD levels (each >= 0) to include in the returned chunk's `lods`. Ignored when `includeAllLods` is true. Omit to apply no LOD filtering. */
    requestedLodLevels?: InputMaybe<Array<Scalars['Int']['input']>>;
};
/** Arguments for getChunkLods: selects the LOD meshes for one chunk and returns only the requested levels. */
export type GetChunkLodsInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk whose LODs to fetch. */
    coordinates: ChunkCoordinatesInput;
    /** LOD levels to return (each >= 0; 0 is the finest). Only matching levels are included in the response. */
    lodLevels: Array<Scalars['Int']['input']>;
};
/** Arguments for getChunksByDistance: selects chunks within a cubic (Chebyshev-distance) radius around a center chunk, with pagination. */
export type GetChunksByDistanceInput = {
    /** Id of the app whose chunks to search (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Center chunk of the search cube. */
    centerCoordinate: ChunkCoordinatesInput;
    /** Maximum number of chunks to return. Defaults to 1000 when omitted. Must be >= 0. */
    limit?: InputMaybe<Scalars['Int']['input']>;
    /** Cube 'radius' in chunks measured as Chebyshev distance: matches chunks whose x, y and z each differ from the center by at most this many chunks (a (2*maxDistance+1)^3 cube). Integer, 1-8 inclusive. */
    maxDistance: Scalars['Int']['input'];
    /** Number of chunks to skip for pagination. Defaults to 0 when omitted. Must be >= 0. */
    skip?: InputMaybe<Scalars['Int']['input']>;
};
/** Arguments for getVoxelList: selects all recorded voxel edits for one chunk by app id and chunk coordinates. */
export type GetVoxelListInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk whose voxel edits to list. */
    coordinates: ChunkCoordinatesInput;
};
/** A snapshot of an app's game-model footprint and recent activity: row counts in the database plus invocation activity. Helps developers understand what is in their game and their database. */
export type GmAppDiagnostics = {
    __typename?: 'GmAppDiagnostics';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** Defined automations. */
    automationCount: Scalars['Int']['output'];
    /** Automation-driven invocations in the last 24h. */
    automationEvents24h: Scalars['Int']['output'];
    /** Container instances in the app. */
    containerCount: Scalars['Int']['output'];
    /** Edge rows in the app. */
    edgeCount: Scalars['Int']['output'];
    /** Total event-log rows (all time). */
    eventCount: Scalars['Int']['output'];
    /** Event-log rows in the last 24h. */
    events24h: Scalars['Int']['output'];
    /** Failed invocations in the last 24h. */
    failedEvents24h: Scalars['Int']['output'];
    /** Defined functions. */
    functionCount: Scalars['Int']['output'];
    /** Property rows in the app. */
    propertyCount: Scalars['Int']['output'];
    /** Sessions in the app. */
    sessionCount: Scalars['Int']['output'];
    /** Most-invoked functions in the last 24h. */
    topFunctions: Array<GmTopFunction>;
};
/** An app feature key that functions can gate on and tiers can grant. */
export type GmAppFeature = {
    __typename?: 'GmAppFeature';
    /** The app (tenant) that defines the feature. */
    appId: Scalars['BigInt']['output'];
    /** Optional description of the feature. */
    description: Maybe<Scalars['String']['output']>;
    /** The feature key (referenced by tier_feature authority rules). */
    featureKey: Scalars['String']['output'];
};
/** The app's game-model runtime policy. */
export type GmAppPolicy = {
    __typename?: 'GmAppPolicy';
    /** The app (tenant) the policy applies to. */
    appId: Scalars['BigInt']['output'];
    /** Default role assigned to new session participants. */
    defaultParticipantRole: Scalars['String']['output'];
    /** Who may create sessions: admin | member | anyone. */
    sessionCreationPolicy: Scalars['String']['output'];
};
/** An autonomous process (automation / NPC): a server-driven entry-point function bound to a trigger (schedule or model activity) plus a safety budget and circuit-breaker state. */
export type GmAutomation = {
    __typename?: 'GmAutomation';
    /** Action kind: model_function (invoke a Model function) or compute_invoke (invoke a compute-module export). */
    actionKind: Scalars['String']['output'];
    /** The app (tenant) that owns the automation. */
    appId: Scalars['BigInt']['output'];
    /** Unique automation id (UUID). */
    automationId: Scalars['String']['output'];
    /** Circuit-breaker state: closed | open | half_open. */
    circuitState: Scalars['String']['output'];
    /** For action_kind=compute_invoke: the module invoke export called. */
    computeExport: Maybe<Scalars['String']['output']>;
    /** For action_kind=compute_invoke: the compute module name invoked. */
    computeModuleName: Maybe<Scalars['String']['output']>;
    /** Current consecutive-failure count. */
    consecutiveFailures: Scalars['Int']['output'];
    /** Cooldown (ms) while the circuit is open. */
    cooldownMs: Scalars['Int']['output'];
    /** Cron expression (schedule_kind=cron). */
    cronExpr: Maybe<Scalars['String']['output']>;
    /** Optional description. */
    description: Maybe<Scalars['String']['output']>;
    /** Whether the automation is eligible to run. */
    enabled: Scalars['Boolean']['output'];
    /** Consecutive failures that trip the circuit breaker. */
    failureThreshold: Scalars['Int']['output'];
    /** The entry-point function name (must be autonomous_invocable). Null for compute_invoke actions. */
    functionName: Maybe<Scalars['String']['output']>;
    /** Override: evaluation gas per invoke. */
    gasLimit: Maybe<Scalars['Int']['output']>;
    /** Interval in ms (schedule_kind=interval). */
    intervalMs: Maybe<Scalars['Int']['output']>;
    /** Last error recorded for this automation. */
    lastError: Maybe<Scalars['String']['output']>;
    /** When the automation last ran. */
    lastRunAt: Maybe<Scalars['DateTime']['output']>;
    /** Override: max fn: call depth per invoke. */
    maxFnDepth: Maybe<Scalars['Int']['output']>;
    /** Max runs per minute for this automation. */
    maxRunsPerMinute: Scalars['Int']['output'];
    /** Max targets per run (fan-out cap). */
    maxTargets: Scalars['Int']['output'];
    /** Automation name (unique per app); the upsert key. */
    name: Scalars['String']['output'];
    /** When the automation is next due (schedule). */
    nextRunAt: Maybe<Scalars['DateTime']['output']>;
    /** JSON object of static params passed to the entry point. */
    paramsJson: Scalars['String']['output'];
    /** When the open circuit may retry (half-open). */
    pausedUntil: Maybe<Scalars['DateTime']['output']>;
    /** Identity the automation acts as (drives owner_of_self / $caller_user_id). Null = trusted server caller. */
    runAsUserId: Maybe<Scalars['BigInt']['output']>;
    /** Override: wall-clock budget per invoke (ms). */
    runTimeoutMs: Maybe<Scalars['Int']['output']>;
    /** For schedule triggers: interval | cron. */
    scheduleKind: Maybe<Scalars['String']['output']>;
    /** JSON selector that resolves candidate refs/scalars over model data (e.g. nearest enemy) into params. Null when unused. */
    selectorJson: Maybe<Scalars['String']['output']>;
    /** For target_mode=container: the specific self container UUID. */
    selfContainerId: Maybe<Scalars['String']['output']>;
    /** Optional session scope (UUID). */
    sessionId: Maybe<Scalars['String']['output']>;
    /** Target resolution mode: container | type | global. */
    targetMode: Scalars['String']['output'];
    /** For target_mode=type: the container type to fan out over. */
    targetTypeName: Maybe<Scalars['String']['output']>;
    /** Trigger type: schedule | event | manual. */
    triggerType: Scalars['String']['output'];
};
/** Per-app guardrails / platform ceilings for autonomous processes. */
export type GmAutomationPolicy = {
    __typename?: 'GmAutomationPolicy';
    /** The app (tenant) the policy applies to. */
    appId: Scalars['BigInt']['output'];
    /** App-wide kill switch for all automations. */
    enabled: Scalars['Boolean']['output'];
    /** Maximum aggregate automation runs per minute for the app. */
    globalRunsPerMinute: Scalars['Int']['output'];
    /** Maximum number of automations the app may define. */
    maxAutomations: Scalars['Int']['output'];
    /** Maximum event-trigger cascade depth. */
    maxCascadeDepth: Scalars['Int']['output'];
    /** Maximum fan-out targets per run. */
    maxFanout: Scalars['Int']['output'];
    /** Maximum pending (armed but not yet fired) timers the app may hold at once. */
    maxPendingTimers: Scalars['Int']['output'];
    /** Minimum allowed schedule interval (ms) floor. */
    minIntervalMs: Scalars['Int']['output'];
    /** Minimum timer delay (ms) floor for gameModelScheduleInvoke and function timer effects. */
    minTimerDelayMs: Scalars['Int']['output'];
};
/** One execution of an automation: its target/fan-out + invocation counts, timing, outcome, circuit action, and billed compute. The monitoring + billing record. */
export type GmAutomationRun = {
    __typename?: 'GmAutomationRun';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** The automation that ran, or null for a timer fire (which has no owning automation). */
    automationId: Maybe<Scalars['String']['output']>;
    /** The automation name at run time, or the invoked function name for a timer fire. */
    automationName: Scalars['String']['output'];
    /** Cascade depth (0 = top-level). */
    cascadeDepth: Scalars['Int']['output'];
    /** Circuit action taken (e.g. opened, half_open_retry, budget_paused, cascade_dropped, rate_limited). */
    circuitAction: Maybe<Scalars['String']['output']>;
    /** Billed compute units for this run. */
    computeUnits: Scalars['Int']['output'];
    /** Wall-clock duration in microseconds. */
    durationUs: Scalars['Int']['output'];
    /** Error message when the run failed. */
    errorMessage: Maybe<Scalars['String']['output']>;
    /** When the run finished. */
    finishedAt: Maybe<Scalars['DateTime']['output']>;
    /** Flow correlation id: shared with gm event-log rows and compute module runs triggered by the same entry call (player invoke / automation run / computeInvoke). */
    flowId: Maybe<Scalars['String']['output']>;
    /** Number of fn: user-function calls across invocations. */
    fnCalls: Scalars['Int']['output'];
    /** Evaluation gas consumed across invocations. */
    gasUsed: Scalars['Int']['output'];
    /** Number of function invocations performed. */
    invocations: Scalars['Int']['output'];
    /** Number of property mutations applied across invocations. */
    mutations: Scalars['Int']['output'];
    /** Parent run id when triggered as a cascade. */
    parentRunId: Maybe<Scalars['String']['output']>;
    /** Unique run id (UUID). */
    runId: Scalars['String']['output'];
    /** When the run started. */
    startedAt: Scalars['DateTime']['output'];
    /** Whether the run succeeded. */
    success: Scalars['Boolean']['output'];
    /** Number of target containers acted on (fan-out). */
    targets: Scalars['Int']['output'];
    /** The event trigger that matched, when the run came from one. Null for schedule, manual, and timer-fired runs. */
    triggerId: Maybe<Scalars['String']['output']>;
    /** What triggered the run: schedule | event | manual | cascade | timer. */
    triggerSource: Scalars['String']['output'];
};
/** Per-automation rollup within a stats window. */
export type GmAutomationStat = {
    __typename?: 'GmAutomationStat';
    /** The automation name. */
    automationName: Scalars['String']['output'];
    /** Average run duration (microseconds). */
    avgDurationUs: Scalars['Int']['output'];
    /** Current circuit-breaker state: closed | open | half_open. */
    circuitState: Scalars['String']['output'];
    /** Total compute units consumed. */
    computeUnits: Scalars['Int']['output'];
    /** Failed runs in the window. */
    failures: Scalars['Int']['output'];
    /** Total invocations across runs. */
    invocations: Scalars['Int']['output'];
    /** Runs in the window. */
    runs: Scalars['Int']['output'];
};
/** Aggregate automation activity for an app over a recent window: throughput, failure rate, compute, and a per-automation breakdown. The "what are my NPCs doing" view. */
export type GmAutomationStats = {
    __typename?: 'GmAutomationStats';
    /** Average run duration in microseconds. */
    avgDurationUs: Scalars['Int']['output'];
    /** Per-automation breakdown. */
    byAutomation: Array<GmAutomationStat>;
    /** Failed runs in the window. */
    failedRuns: Scalars['Int']['output'];
    /** Failure rate as a percentage (0-100). */
    failureRatePct: Scalars['Float']['output'];
    /** Average runs per minute over the window. */
    runsPerMinute: Scalars['Float']['output'];
    /** Total billed compute units in the window. */
    totalComputeUnits: Scalars['Int']['output'];
    /** Total function invocations across runs. */
    totalInvocations: Scalars['Int']['output'];
    /** Total property mutations across runs. */
    totalMutations: Scalars['Int']['output'];
    /** Total runs in the window. */
    totalRuns: Scalars['Int']['output'];
    /** The window size in minutes. */
    windowMinutes: Scalars['Int']['output'];
};
/** An event subscription that fires an automation in reaction to model activity or a complete app-scoped active-player-count transition (matched in the API server, not a DB trigger). */
export type GmAutomationTrigger = {
    __typename?: 'GmAutomationTrigger';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** The automation this trigger fires. */
    automationId: Scalars['String']['output'];
    /** Filter: only this container type. Always null for player_count_changed. */
    containerTypeName: Maybe<Scalars['String']['output']>;
    /** Debounce window in ms. player_count_changed coalesces on the trailing edge; other model events use their existing leading-edge behavior. */
    debounceMs: Scalars['Int']['output'];
    /** Filter: only this function name. Always null for player_count_changed. */
    functionName: Maybe<Scalars['String']['output']>;
    /** When this trigger last matched an event and dispatched a run, or null if it has never matched. A trigger that stays null while its event is happening is almost always a filter that cannot match — see warnings. */
    lastMatchedAt: Maybe<Scalars['DateTime']['output']>;
    /** Runs this trigger dispatched in the last 24 hours, including runs a guard then dropped. Fires suppressed by debounceMs never reach a run and are not counted. */
    matchCount24h: Scalars['Int']['output'];
    /** Observed event: function_invoked | property_changed | container_created | player_count_changed. */
    onEvent: Scalars['String']['output'];
    /** Filter: only this property key. Always null for player_count_changed. */
    propertyKey: Maybe<Scalars['String']['output']>;
    /** Unique trigger id (UUID). */
    triggerId: Scalars['String']['output'];
    /** Authoring problems detected for this trigger, empty when healthy. Reported rather than silently never firing. */
    warnings: Array<Scalars['String']['output']>;
    /** property_changed only: which writes are observed — "direct" (gameModelSetProperty), "function" (a mutation applied inside an invoke, automation run, or timer fire), or "any". Always "any" for other events, which ignore it. */
    writeSource: Scalars['String']['output'];
};
/** A container: a runtime instance of a container type (optionally scoped to a session). */
export type GmContainer = {
    __typename?: 'GmContainer';
    /** The app (tenant) that owns the container. */
    appId: Scalars['BigInt']['output'];
    /** Opaque client-derived key the container was ensured under (unique per appId + typeName + sessionId), or null when it was created without one. */
    bindingKey: Maybe<Scalars['String']['output']>;
    /** Unique container id (UUID). */
    containerId: Scalars['String']['output'];
    /** Optional description. */
    description: Maybe<Scalars['String']['output']>;
    /** Human-friendly display name. */
    displayName: Scalars['String']['output'];
    /** JSON object of developer metadata. */
    metadataJson: Scalars['String']['output'];
    /** The owning user, or null if unowned. */
    ownerUserId: Maybe<Scalars['BigInt']['output']>;
    /** Owning session id, or null for an app-global container. */
    sessionId: Maybe<Scalars['String']['output']>;
    /** The container type name. */
    typeName: Scalars['String']['output'];
};
/** One container-change notification from gameModelContainerChanged. Metadata only (no property values): clients pull the visibility-filtered state with gameModelContainerState on receipt. Delivery is post-commit and best-effort, like model-driven notifications. */
export type GmContainerChange = {
    __typename?: 'GmContainerChange';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** The property keys the change touched (empty for created/deleted; clamped to 32 keys). */
    changedKeys: Array<Scalars['String']['output']>;
    /** The container that changed. */
    containerId: Scalars['String']['output'];
    /** For source='function': the function that mutated it. */
    functionName: Maybe<Scalars['String']['output']>;
    /** When the change committed. */
    occurredAt: Scalars['DateTime']['output'];
    /** The session scope of the change, when any. */
    sessionId: Maybe<Scalars['String']['output']>;
    /** What changed it: 'function' (invoke mutation), 'direct' (gameModelSetProperty), 'created', or 'deleted'. */
    source: Scalars['String']['output'];
    /** The container type (null if the type is unknown). */
    typeName: Maybe<Scalars['String']['output']>;
};
/** A container plus its property values filtered to what the requesting caller is allowed to see. */
export type GmContainerState = {
    __typename?: 'GmContainerState';
    /** The app (tenant) that owns the container. */
    appId: Scalars['BigInt']['output'];
    /** The container id (UUID). */
    containerId: Scalars['String']['output'];
    /** Human-friendly display name. */
    displayName: Scalars['String']['output'];
    /** The owning user, or null if unowned. */
    ownerUserId: Maybe<Scalars['BigInt']['output']>;
    /** JSON object of visible properties (filtered by the caller). */
    propertiesJson: Scalars['String']['output'];
    /** Owning session id, or null if app-global. */
    sessionId: Maybe<Scalars['String']['output']>;
    /** The container type name. */
    typeName: Scalars['String']['output'];
};
/** A studio-defined container type: the schema for a kind of runtime entity (like a class). */
export type GmContainerType = {
    __typename?: 'GmContainerType';
    /** The app (tenant) that owns the type. */
    appId: Scalars['BigInt']['output'];
    /** Who may CREATE a container of this type under a client-supplied bindingKey (gameModelEnsureContainer). Same JSON shape as a function invokePolicyJson — an AuthorityRule tree — except that owner_of_self, is_current_turn and condition are refused, because a bind creates the container and there is no acting container to resolve them against. Omit it (the default) and binding is governed by the type's instantiableBy alone, which is the behaviour before this field existed. Resolving an EXISTING key is unaffected: it is a read. For a shared world object, {"type":"is_host"} or instantiableBy: admin stops one player from squatting the key and becoming its owner. */
    bindPolicyJson: Maybe<Scalars['String']['output']>;
    /** Default visibility for this type's properties: public | owner | hidden. */
    defaultPropertyVisibility: Scalars['String']['output'];
    /** Optional description of the type. */
    description: Maybe<Scalars['String']['output']>;
    /** Human-friendly display name. */
    displayName: Scalars['String']['output'];
    /** Who may instantiate this type: admin | member | owner. */
    instantiableBy: Scalars['String']['output'];
    /** JSON object of developer metadata. */
    metadataJson: Scalars['String']['output'];
    /** Stable type name (unique per app); used to reference the type. */
    typeName: Scalars['String']['output'];
};
/** A directed relationship edge between two containers. */
export type GmEdge = {
    __typename?: 'GmEdge';
    /** Unique edge id (UUID). */
    edgeId: Scalars['String']['output'];
    /** Source container id. */
    fromContainerId: Scalars['String']['output'];
    /** The relationship type label. */
    relationshipType: Scalars['String']['output'];
    /** Target container id. */
    toContainerId: Scalars['String']['output'];
    /** Optional edge weight. */
    weight: Maybe<Scalars['Float']['output']>;
};
/** Result of gameModelEnsureContainer: the resolved container plus whether this call inserted it. */
export type GmEnsureContainerResult = {
    __typename?: 'GmEnsureContainerResult';
    /** The container all ensures of this key converge on. */
    container: GmContainer;
    /** True when THIS call created the row; false when it resolved an existing one (creation-only input fields were ignored). */
    created: Scalars['Boolean']['output'];
};
/** An audit-log entry recording one function invocation and its outcome. */
export type GmEvent = {
    __typename?: 'GmEvent';
    /** The automation (autonomous process) that drove this invocation, if any. */
    automationId: Maybe<Scalars['String']['output']>;
    /** Who invoked: player | automation | system. Distinguishes NPC/autonomous-process actions from player actions. */
    callerKind: Scalars['String']['output'];
    /** The user who invoked the function. */
    callerUserId: Maybe<Scalars['BigInt']['output']>;
    /** Error message when the invocation failed. */
    errorMessage: Maybe<Scalars['String']['output']>;
    /** Unique event id. */
    eventId: Scalars['String']['output'];
    /** When the invocation executed. */
    executedAt: Scalars['DateTime']['output'];
    /** Flow correlation id: shared with automation runs and compute module runs caused by the same entry call (player invoke / automation run / computeInvoke), so cross-engine flows can be stitched together. */
    flowId: Maybe<Scalars['String']['output']>;
    /** The function that was invoked. */
    functionName: Scalars['String']['output'];
    /** JSON array of applied mutations. */
    mutationsAppliedJson: Scalars['String']['output'];
    /** JSON object of params. */
    paramsJson: Scalars['String']['output'];
    /** JSON array of grid-permission effects this invocation applied (audit trail for model-driven grants/revokes): [{ action, permission_keys, user_id, grid_id, expires_at }]. */
    permissionEffectsAppliedJson: Scalars['String']['output'];
    /** JSON-encoded return value. */
    returnValueJson: Maybe<Scalars['String']['output']>;
    /** The self container id the function ran against. */
    selfContainerId: Maybe<Scalars['String']['output']>;
    /** The session the invocation ran in, if any. */
    sessionId: Maybe<Scalars['String']['output']>;
    /** True if the invocation succeeded. */
    success: Scalars['Boolean']['output'];
};
/** An edge in a GmEvent connection. */
export type GmEventEdge = {
    __typename?: 'GmEventEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: GmEvent;
};
/** The stitched cross-engine timeline for one flow correlation id: every model event, automation run, and compute module run that shares the flow_id minted at the entry edge (player invoke / automation run / computeInvoke). Each array is ordered by time ascending, so the three together read as one causal diagnostics trace (e.g. mob kill -> compute event -> reward grant). */
export type GmFlowTimeline = {
    __typename?: 'GmFlowTimeline';
    /** Automation (autonomous process) runs in the flow, ordered by startedAt ascending. */
    automationRuns: Array<GmAutomationRun>;
    /** Model function-invocation events (gm_event_log rows) in the flow, ordered by executedAt ascending. */
    events: Array<GmEvent>;
    /** The flow correlation id (UUID) this timeline was built for. */
    flowId: Scalars['String']['output'];
    /** Compute module runs in the flow, ordered by startedAt ascending. */
    moduleRuns: Array<WasmModuleRun>;
};
/** A studio-defined function: a named, sandboxed behavior over containers (parameters, declared mutations, optional return, and an authority invoke policy). */
export type GmFunction = {
    __typename?: 'GmFunction';
    /** The app (tenant) that owns the function. */
    appId: Scalars['BigInt']['output'];
    /** Whether an autonomous process (automation/NPC) may use this function as an entry point. Players are unaffected by this flag. */
    autonomousInvocable: Scalars['Boolean']['output'];
    /** Optional container type this function is bound to (null = global). */
    containerTypeName: Maybe<Scalars['String']['output']>;
    /** Optional description of the function. */
    description: Maybe<Scalars['String']['output']>;
    /** Unique function id (UUID). */
    functionId: Scalars['String']['output'];
    /** JSON-encoded invoke policy rule tree. */
    invokePolicyJson: Maybe<Scalars['String']['output']>;
    /** Who may invoke and in what context: player | server | internal. */
    invokeScope: Scalars['String']['output'];
    /** The property writes the function performs when invoked. */
    mutations: Array<GmFunctionMutation>;
    /** Function name (unique per app); used to invoke it. */
    name: Scalars['String']['output'];
    /** Declarative realtime notifications the function emits via Buddy after it commits. */
    notifications: Array<GmFunctionNotification>;
    /** Typed parameters the function accepts. */
    parameters: Array<GmFunctionParam>;
    /** Declarative grid-permission effects (grant/revoke runtime grid ACL rows) applied atomically with the function's mutations. */
    permissionEffects: Array<GmFunctionPermissionEffect>;
    /** Optional expression whose value becomes the invoke result. */
    returnExpression: Maybe<Scalars['String']['output']>;
    /** Optional declared return value type. */
    returnType: Maybe<Scalars['String']['output']>;
    /** Declarative one-shot timers armed atomically with the function's mutations. */
    timers: Array<GmFunctionTimer>;
    /** Non-fatal static-analysis warnings from the last upload. */
    warnings: Array<Scalars['String']['output']>;
};
/** The player-invoke breaker's mode and thresholds on the answering instance, with this app's circuits. The mode decides whether any of it refuses anything. */
export type GmFunctionBreakerStatus = {
    __typename?: 'GmFunctionBreakerStatus';
    /** Circuits for this app, non-closed first, then by consecutive failures. Only functions that have failed at least once appear. */
    circuits: Array<GmFunctionCircuit>;
    /** How long an open circuit waits before admitting one probe, in milliseconds. */
    cooldownMs: Scalars['Int']['output'];
    /** Consecutive failed player invokes of one function before its circuit opens. */
    failureThreshold: Scalars['Int']['output'];
    /** 'shadow' (default: the state machine runs in full, every call is admitted, and shadowRefusals counts what enforcement would have refused), 'enforce' (the same state machine, refusing), or 'off' (no state, no measurement). Read from GM_FUNCTION_BREAKER_MODE on the instance that answered. */
    mode: Scalars['String']['output'];
};
/** One model function's circuit on the player-invoke path. Rows are created lazily on a function's first failure, so a function absent from this list has never failed. */
export type GmFunctionCircuit = {
    __typename?: 'GmFunctionCircuit';
    /** App the function belongs to. */
    appId: Scalars['BigInt']['output'];
    /** 'closed', 'open', or 'half_open'. In shadow mode an open circuit refuses nothing: read it as 'this function has been failing', not 'players are being blocked'. */
    circuitState: Scalars['String']['output'];
    /** Failed player invokes with no success in between. One success resets it to zero, which is what makes the threshold mean a broken function rather than a busy one. */
    consecutiveFailures: Scalars['Int']['output'];
    /** When an open circuit next admits one probe, and the window that probe holds. Null when closed. */
    cooldownUntil: Maybe<Scalars['DateTime']['output']>;
    /** Function name as a player invokes it, matching gm_function_defs.name. A renamed function starts with a clean circuit. */
    functionName: Scalars['String']['output'];
    /** When the circuit last opened. Null if it never has. */
    openedAt: Maybe<Scalars['DateTime']['output']>;
    /** Player invokes admitted in shadow mode that enforcement WOULD have refused. This is the measurement: it answers what switching enforcement on would have cost players. Never incremented in enforce mode, where those calls are refused instead. */
    shadowRefusals: Scalars['BigInt']['output'];
    /** Lifetime openings. A function that opens once a week and one that opens every minute are different problems, and circuitState cannot tell them apart. */
    totalOpens: Scalars['BigInt']['output'];
    /** When the circuit row last changed. */
    updatedAt: Scalars['DateTime']['output'];
};
/** One declared write a function performs: set `property` on `target` to `expression`. */
export type GmFunctionMutation = {
    __typename?: 'GmFunctionMutation';
    /** The expression (source) evaluated to produce the new value. */
    expression: Scalars['String']['output'];
    /** The property key being written. */
    property: Scalars['String']['output'];
    /** Container reference target: self | ref("uuid") | ref($param). */
    target: Scalars['String']['output'];
};
/** A declarative realtime notification the function emits via Buddy AFTER its transaction commits. Fenced by delivery mode (proximity / channel membership / target). */
export type GmFunctionNotification = {
    __typename?: 'GmFunctionNotification';
    /** Named argument expressions. */
    args: Array<GmNotificationArg>;
    /** For kind 'spatial': 'server_event' (default) | 'generic_spatial' | 'actor_update'. */
    emitAs: Maybe<Scalars['String']['output']>;
    /** Delivery mode: 'spatial' | 'channel' | 'actor'. */
    kind: Scalars['String']['output'];
};
/** A typed parameter of a studio-defined function. */
export type GmFunctionParam = {
    __typename?: 'GmFunctionParam';
    /** JSON-encoded default value. */
    defaultValueJson: Maybe<Scalars['String']['output']>;
    /** Optional description of the parameter. */
    description: Maybe<Scalars['String']['output']>;
    /** Parameter name (referenced as $name in expressions). */
    name: Scalars['String']['output'];
    /** Whether the parameter is required at invoke time. */
    required: Scalars['Boolean']['output'];
    /** Display/order index of the parameter. */
    sortOrder: Scalars['Int']['output'];
    /** Value type: int | float | string | bool | array | object | container_ref. */
    valueType: Scalars['String']['output'];
};
/** A declarative grid-permission effect applied transactionally with the function's mutations: grant or revoke runtime grid permissions (the ACL Buddy enforces) driven by game logic. */
export type GmFunctionPermissionEffect = {
    __typename?: 'GmFunctionPermissionEffect';
    /** 'grant' or 'revoke'. */
    action: Scalars['String']['output'];
    /** The expression (source) resolving the grid id. */
    gridIdExpression: Scalars['String']['output'];
    /** Runtime permission keys granted/revoked. */
    permissionKeys: Array<Scalars['String']['output']>;
    /** Grant only: optional expression resolving a TTL in seconds. */
    ttlSecondsExpression: Maybe<Scalars['String']['output']>;
    /** The expression (source) resolving the target user id. */
    userExpression: Scalars['String']['output'];
};
/** A declarative one-shot timer the function arms transactionally with its mutations: invoke another function after a delay. Fires exactly once, survives replica restarts, and is bounded by the app's automation guardrails. */
export type GmFunctionTimer = {
    __typename?: 'GmFunctionTimer';
    /** Optional expression (source) resolving the app-scoped dedupe key; re-arming the same key replaces the pending timer. */
    dedupeKeyExpression: Maybe<Scalars['String']['output']>;
    /** The expression (source) resolving the delay in milliseconds. */
    delayMsExpression: Scalars['String']['output'];
    /** The function invoked when the timer fires. */
    functionName: Scalars['String']['output'];
    /** Parameters bound into the delayed invocation. */
    params: Array<GmTimerParam>;
    /** Container reference (source) the delayed invocation runs against, e.g. "self". */
    target: Scalars['String']['output'];
};
/** The outcome of a gameModelInvoke call (return value, applied writes, and any error). */
export type GmInvokeResult = {
    __typename?: 'GmInvokeResult';
    /**
     * A platform-authored sentence matching `fault`, safe to show a player. It carries no engine detail on purpose (decision D4): the failing expression, the timeout and the gas figures are in gameModelEvents and the fault record, where a developer reads them and a player does not.
     * @deprecated Read `fault` instead and choose your own wording. This field no longer carries the engine's error text and will be removed once no client depends on it.
     */
    errorMessage: Maybe<Scalars['String']['output']>;
    /** The id of the event logged for this invocation. */
    eventId: Scalars['String']['output'];
    /** Why the invocation failed, when it did: a stable code, whose problem it is, and whether retrying could help. Null when success is true. This is the field to branch on — it is the platform's blame attribution, and rendering is the game's decision. */
    fault: Maybe<PlayerFaultInfo>;
    /** The function that was invoked. */
    functionName: Scalars['String']['output'];
    /** The property writes that were applied (empty if none / on failure). */
    mutationsApplied: Array<GmMutationApplied>;
    /** JSON-encoded return value. */
    returnValueJson: Maybe<Scalars['String']['output']>;
    /** True if the invocation succeeded; false if it was rejected or errored. */
    success: Scalars['Boolean']['output'];
};
/** One property write applied during a function invocation (with before/after values). */
export type GmMutationApplied = {
    __typename?: 'GmMutationApplied';
    /** The container that was written. */
    containerId: Scalars['String']['output'];
    /** The property key written. */
    key: Scalars['String']['output'];
    /** JSON-encoded value after the write. */
    newValueJson: Maybe<Scalars['String']['output']>;
    /** JSON-encoded value before the write. */
    oldValueJson: Maybe<Scalars['String']['output']>;
    /** The value type written. */
    valueType: Scalars['String']['output'];
};
/** One named argument expression of a notify_* effect. */
export type GmNotificationArg = {
    __typename?: 'GmNotificationArg';
    /** The expression (source) evaluated post-mutation to produce the value. */
    expression: Scalars['String']['output'];
    /** Argument name (kind-specific: chunk_x, channel_id, payload, target_uuid, ...). */
    name: Scalars['String']['output'];
};
/** A typed property (field) defined on a container type. */
export type GmPropertyDef = {
    __typename?: 'GmPropertyDef';
    /** The app (tenant) that owns the type. */
    appId: Scalars['BigInt']['output'];
    /** The container type this property belongs to. */
    containerTypeName: Scalars['String']['output'];
    /** JSON-encoded default value. */
    defaultValueJson: Maybe<Scalars['String']['output']>;
    /** Optional description of the property. */
    description: Maybe<Scalars['String']['output']>;
    /** Property key (unique within the type). */
    key: Scalars['String']['output'];
    /** Value type: int | float | string | bool | array | object | container_ref. */
    valueType: Scalars['String']['output'];
    /** Read visibility: public | owner | hidden. */
    visibility: Scalars['String']['output'];
    /** Who may write the property: function | owner | admin. */
    writable: Scalars['String']['output'];
};
/** One property predicate for filtered container lists (the same shape automation selectors use): compare a property value against a JSON literal. Missing properties fall back to the type default. */
export type GmPropertyPredicateInput = {
    /** Property key to compare. */
    key: Scalars['String']['input'];
    /** Comparison operator: '==', '!=', '<', '>', '<=' or '>='. */
    op: Scalars['String']['input'];
    /** JSON-encoded comparison value (e.g. '"enemy"', 'true', '10'). */
    valueJson: Scalars['String']['input'];
};
/** Summary of what a gameModelSeed call created. */
export type GmSeedResult = {
    __typename?: 'GmSeedResult';
    /** Number of container types created. */
    containerTypesCreated: Scalars['Int']['output'];
    /** Number of containers (instances) created. */
    containersCreated: Scalars['Int']['output'];
    /** Number of edges created. */
    edgesCreated: Scalars['Int']['output'];
    /** Number of functions created. */
    functionsCreated: Scalars['Int']['output'];
    /** JSON object mapping seed temp_id -> created container UUID. */
    idMapJson: Scalars['String']['output'];
    /** Number of property definitions created. */
    propertyDefinitionsCreated: Scalars['Int']['output'];
    /** Non-fatal warnings produced while seeding. */
    warnings: Array<Scalars['String']['output']>;
};
/** A runtime session: an isolated instance scope (e.g. a match or room) for containers. */
export type GmSession = {
    __typename?: 'GmSession';
    /** The app (tenant) that owns the session. */
    appId: Scalars['BigInt']['output'];
    /** The user who created the session. */
    createdByUserId: Maybe<Scalars['BigInt']['output']>;
    /** The user whose turn it currently is (turn-based play), or null. */
    currentTurnUserId: Maybe<Scalars['BigInt']['output']>;
    /** JSON object of developer metadata. */
    metadataJson: Scalars['String']['output'];
    /** Optional session name. */
    name: Maybe<Scalars['String']['output']>;
    /** Unique session id. */
    sessionId: Scalars['String']['output'];
    /** Lifecycle status (e.g. active). */
    status: Scalars['String']['output'];
};
/** A user's participation in a session. */
export type GmSessionParticipant = {
    __typename?: 'GmSessionParticipant';
    /** The participant role within the session. */
    role: Scalars['String']['output'];
    /** The session id. */
    sessionId: Scalars['String']['output'];
    /** The participant user id. */
    userId: Scalars['BigInt']['output'];
};
/** A grant of a feature key to an access tier. */
export type GmTierFeature = {
    __typename?: 'GmTierFeature';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** The feature key granted to the tier. */
    featureKey: Scalars['String']['output'];
    /** The access tier the feature is granted to. */
    tierId: Scalars['BigInt']['output'];
};
/** A pending one-shot timer: a delayed invocation that has been armed but has not fired yet. Timers are removed from this list the moment they are claimed for execution. */
export type GmTimer = {
    __typename?: 'GmTimer';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** What armed it: function (a timer effect inside an invoke) | client (gameModelScheduleInvoke) | automation. */
    armedBy: Scalars['String']['output'];
    /** Cascade depth inherited from whatever armed the timer. The fired invocation runs one deeper, so timer chains are bounded by the app's maxCascadeDepth. */
    cascadeDepth: Scalars['Int']['output'];
    /** When the timer was armed. */
    createdAt: Scalars['DateTime']['output'];
    /** App-scoped dedupe key, or null. Re-arming the same key replaces this timer instead of adding another. */
    dedupeKey: Maybe<Scalars['String']['output']>;
    /** When the timer becomes due. */
    fireAt: Scalars['DateTime']['output'];
    /** Flow correlation id carried from the arming call, so the eventual fire stays visible in gameModelFlow. */
    flowId: Maybe<Scalars['String']['output']>;
    /** The function that will be invoked when it fires. */
    functionName: Scalars['String']['output'];
    /** JSON object of parameters bound at arm time and passed to the invocation. */
    paramsJson: Scalars['String']['output'];
    /** Container the delayed invocation runs against ("self"). */
    selfContainerId: Scalars['String']['output'];
    /** Session the delayed invocation runs in, or null if app-global. */
    sessionId: Maybe<Scalars['String']['output']>;
    /** Unique timer id (UUID). */
    timerId: Scalars['String']['output'];
};
/** One named parameter expression bound into a timer invocation at arm time. */
export type GmTimerParam = {
    __typename?: 'GmTimerParam';
    /** The expression (source) evaluated when arming. */
    expression: Scalars['String']['output'];
    /** Parameter name on the timer's target function. */
    name: Scalars['String']['output'];
};
/** A function and its recent invocation counts (diagnostics). */
export type GmTopFunction = {
    __typename?: 'GmTopFunction';
    /** Failed invocations in the window. */
    failures: Scalars['Int']['output'];
    /** The function name. */
    functionName: Scalars['String']['output'];
    /** Invocations in the window. */
    invocations: Scalars['Int']['output'];
};
/** The result of a graph traversal: the reachable container nodes and the edges between them. */
export type GmTraverseResult = {
    __typename?: 'GmTraverseResult';
    /** Edges traversed, of the requested relationship type. */
    edges: Array<GmEdge>;
    /** Containers reached within the requested depth. */
    nodes: Array<GmContainer>;
    /** The root container the traversal started from. */
    rootId: Scalars['String']['output'];
};
/** A container type's complete schema: its property definitions and available functions. */
export type GmTypeSchema = {
    __typename?: 'GmTypeSchema';
    /** The functions available on the type. */
    functions: Array<GmFunction>;
    /** The type's property definitions. */
    propertyDefinitions: Array<GmPropertyDef>;
    /** The container type name. */
    typeName: Scalars['String']['output'];
};
/** Human-grant a visible, scoped Play lease for the current grid/entity/host revision. */
export type GrantAgentLeaseInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Current player-controlled entity identifier, capped at 128 characters. */
    controlledEntityId: Scalars['String']['input'];
    /** Human-selected duration in seconds (1–600); no silent renewal. */
    durationSeconds: Scalars['Int']['input'];
    /** Exact current host capability revision. */
    hostCapabilityRevision: Scalars['String']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Explicit unique Play scopes: observe, locomotion, interact, craft, combat, communicate, or travel. */
    scopes: Array<Scalars['String']['input']>;
    /** Owner/app PLAY session UUID. */
    sessionId: Scalars['String']['input'];
};
/** Input for granting a user access to an app, optionally on a specific tier. */
export type GrantAppAccessInput = {
    /** Numeric id of the app to grant access to. The caller must hold manage_access_tiers on this app. */
    appId: Scalars['BigInt']['input'];
    /** Optional audit override for who granted access; defaults to the calling user id. Service grants use "system". */
    grantedBy?: InputMaybe<Scalars['String']['input']>;
    /** Optional idempotency key. Recommended for retries: replaying with the same key and identical input returns the first result instead of re-applying; the same key with different input returns IDEMPOTENCY_CONFLICT. Keys expire after 24h. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Optional tier to grant. When omitted, an existing grant keeps its current tier (no tier change). */
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Numeric id of the user who should receive access. */
    userId: Scalars['BigInt']['input'];
};
/** Grant runtime permission keys directly to one user on one grid (writes the grid_user_direct_grants input table). */
export type GrantGridPermissionsInput = {
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['input'];
    /** Optional expiry; after this time the grant stops contributing to the effective ACL. Null/omitted means it never expires. */
    expiresAt?: InputMaybe<Scalars['DateTime']['input']>;
    /** The grid to grant on. */
    gridId: Scalars['BigInt']['input'];
    /** Runtime permission key strings to grant (e.g. update_voxel_data). Each must be a known key in runtime_permissions, unique, and at most 64 chars. */
    permissionKeys: Array<Scalars['String']['input']>;
    /** The user receiving the grant. Must already have active app access for this app. */
    userId: Scalars['BigInt']['input'];
};
/** Grant or revoke a feature key for an access tier. */
export type GrantTierFeatureInput = {
    /** The app (tenant). */
    appId: Scalars['BigInt']['input'];
    /** The feature key to grant to (or revoke from) the tier. */
    featureKey: Scalars['String']['input'];
    /** The access tier id. */
    tierId: Scalars['BigInt']['input'];
};
/** A registered GraphQL API server instance in the fleet, with reachability addresses and basic host telemetry. Returned by graphqlServers (all) and activeGraphQLServers (only ReadyForClients). Use this for service discovery; realtime/UDP play still goes through the game-api UDP proxy. */
export type GraphQlServer = {
    __typename?: 'GraphQLServer';
    /** TCP port the GraphQL/HTTP API listens on (default 4000). */
    apiPort: Scalars['Int']['output'];
    /** Current CPU utilization percentage (0-100) of the host, if reported. */
    cpuUsagePct: Maybe<Scalars['Float']['output']>;
    /** When this server was first registered in the fleet. */
    createdAt: Scalars['DateTime']['output'];
    /** Unique id of this GraphQL server registration. */
    graphqlServerId: Scalars['ID']['output'];
    /** Internal/private IPv4 address of this server. Use publicIp4 for external reachability. */
    ip4: Maybe<Scalars['String']['output']>;
    /** Internal/private IPv6 address of this server. Use publicIp6 for external reachability. */
    ip6: Maybe<Scalars['String']['output']>;
    /** Logical kind of GraphQL service. Every current server is 'game-api', which serves both the management and game surfaces; 'management-api' appears only on rows predating their unification. */
    kind: Maybe<Scalars['String']['output']>;
    /** 1-minute load average of the host, if reported. */
    loadAverage1m: Maybe<Scalars['Float']['output']>;
    /** Current memory utilization percentage (0-100) of the host, if reported. */
    memoryUsagePct: Maybe<Scalars['Float']['output']>;
    /** Cloud provider instance id of the underlying host, if known. */
    providerInstanceId: Maybe<Scalars['String']['output']>;
    /** Public hostname clients can reach this instance on directly over TLS, e.g. `ck-api-or-1.prod.v7.cks-env.com`. Null when the instance has no public DNS name or certificate yet, in which case it is reachable only through the shared load balancer and must not be connected to directly. Prefer the `gameApiUrl` returned by mintAppToken over building a URL from this field: that call already picks a low-load instance for you. */
    publicHostname: Maybe<Scalars['String']['output']>;
    /** Public IPv4 address clients use to reach this server, if assigned. */
    publicIp4: Maybe<Scalars['String']['output']>;
    /** Public IPv6 address clients use to reach this server, if assigned. */
    publicIp6: Maybe<Scalars['String']['output']>;
    /** UUID of the Buddy realtime runtime instance this API server is paired with, if any. */
    runtimeServerId: Maybe<Scalars['String']['output']>;
    /** Current lifecycle state (see ServerState). activeGraphQLServers returns only ReadyForClients. */
    status: ServerState;
    /** When this server row was last updated (heartbeat). Use to judge freshness. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Usage totals for a single GraphQL operation over the window. */
export type GraphqlOperationUsageRow = {
    __typename?: 'GraphqlOperationUsageRow';
    /** GraphQL operation name (or '(anonymous)'). */
    operationName: Scalars['String']['output'];
    /** Total bytes received for this operation (string counter). */
    recvBytes: Scalars['String']['output'];
    /** Total bytes sent for this operation (string counter). */
    sendBytes: Scalars['String']['output'];
    /** Total invocation count (string counter). */
    totalOps: Scalars['String']['output'];
};
/** A grid: a 3D box of chunks within an app that runtime/world (voxel) permissions are scoped to. Its bounds lie inside one of the app's grid assignments and never overlap another grid. */
export type Grid = {
    __typename?: 'Grid';
    /** The app (tenant) that owns the grid. */
    app_id: Scalars['BigInt']['output'];
    /** When the grid was created. */
    created_at: Scalars['DateTime']['output'];
    /** Unique grid id. */
    grid_id: Scalars['BigInt']['output'];
    /** High (maximum x/y/z) corner chunk of the box. */
    high_chunk: ChunkCoordinates;
    /** Low (minimum x/y/z) corner chunk of the box. */
    low_chunk: ChunkCoordinates;
};
/** How a player claim confers grid ownership in this app (D4): SELF_CLAIM (the claim alone assigns ownership), APPROVAL (claims create requests designated approvers accept), INVITE (only against a standing invite), or MARKETPLACE_ONLY (only a marketplace grid purchase; direct claims refused — the purchase edge ships in P4b). */
export declare enum GridClaimPolicy {
    Approval = "APPROVAL",
    Invite = "INVITE",
    MarketplaceOnly = "MARKETPLACE_ONLY",
    SelfClaim = "SELF_CLAIM"
}
/** A pending or decided grid claim request (claim policy 'approval'). Approval assigns grid_ownership to the requester. */
export type GridClaimRequest = {
    __typename?: 'GridClaimRequest';
    /** App of the grid. */
    appId: Scalars['BigInt']['output'];
    /** When the request was created. */
    createdAt: Scalars['DateTime']['output'];
    /** The grid being claimed. */
    gridId: Scalars['BigInt']['output'];
    /** UUID of the request. */
    requestId: Scalars['String']['output'];
    /** The requesting player. */
    requesterUserId: Scalars['BigInt']['output'];
    /** Request status: 'pending', 'approved', 'denied', or 'cancelled'. */
    status: Scalars['String']['output'];
};
/** Result of claimGridOwnership: either ownership was assigned now (SELF_CLAIM / INVITE) or a claim request was created (APPROVAL). MARKETPLACE_ONLY apps refuse direct claims. */
export type GridClaimResult = {
    __typename?: 'GridClaimResult';
    /** UUID of the created claim request in APPROVAL mode; null otherwise. */
    claimRequestId: Maybe<Scalars['String']['output']>;
    /** True when the caller now owns the grid. */
    ownershipAssigned: Scalars['Boolean']['output'];
    /** The app policy that was applied. */
    policy: GridClaimPolicy;
};
/** One marketplace or self-authored client attachment active on a grid, including immutable artifact identity, exact attachment consent, and aggregate per-author capability/trust state. */
export type GridClientMod = {
    __typename?: 'GridClientMod';
    /** UUID of the grid attachment. */
    attachmentId: Scalars['String']['output'];
    /** Hash of authorCapabilitySummaryJson. Any capability widening changes this hash and requires fresh author trust. */
    authorCapabilityHash: Scalars['String']['output'];
    /** JSON aggregate of every active attachment from this author in the grid. This is the summary shown by the one-per-author trust prompt. */
    authorCapabilitySummaryJson: Scalars['String']['output'];
    /** Kind of author whose code this attachment executes. */
    authorKind: PlayerCodeOwnerKind;
    /** User id or org id of the author, according to authorKind. */
    authorRef: Scalars['BigInt']['output'];
    /** Whether the calling player has already consented to this attachment. */
    callerConsented: Scalars['Boolean']['output'];
    /** Whether the caller's grid-author trust matches the current aggregate author capability hash. */
    callerTrustsAuthor: Scalars['Boolean']['output'];
    /** Capability hash a player must consent to before fetching. */
    capabilityHash: Scalars['String']['output'];
    /** JSON derived capability summary of the pinned version. */
    capabilitySummaryJson: Scalars['String']['output'];
    /** Compile artifact hash of the client half. Clients use it as an immutable cache and lifecycle key. */
    clientArtifactHash: Scalars['String']['output'];
    /** Immutable self-authored CLIENT version to fetch; null for marketplace attachments. */
    clientVersionId: Maybe<Scalars['String']['output']>;
    /** The grid the client mod is attached to. */
    gridId: Scalars['BigInt']['output'];
    /** UUID of the marketplace listing, or null for a self-authored attachment. */
    listingId: Maybe<Scalars['String']['output']>;
    /** Listing display name. */
    listingName: Scalars['String']['output'];
    /** Immutable self-authored SERVER version declaring the requirement; null for marketplace attachments. */
    serverVersionId: Maybe<Scalars['String']['output']>;
    /** Attachment source: 'marketplace' or 'self_authored'. */
    sourceKind: Scalars['String']['output'];
    /** UUID of the pinned marketplace version, or null for a self-authored attachment. */
    versionId: Maybe<Scalars['String']['output']>;
};
/** A single group/role -> permission-key grant on a grid (one row of the grid_group_grants input table). */
export type GridGroupGrant = {
    __typename?: 'GridGroupGrant';
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['output'];
    /** When the grant expires; null means it never expires. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** The grid this grant applies to. */
    gridId: Scalars['BigInt']['output'];
    /** The group this grant is for. */
    groupId: Scalars['BigInt']['output'];
    /** Null means the grant applies to all members of the group. */
    groupRoleId: Maybe<Scalars['BigInt']['output']>;
    /** The runtime permission key string granted to the group/role. */
    permissionKey: Scalars['String']['output'];
};
/** A grid listing available in the app store (P4b): a blueprint that stamps a fresh grid per purchase, or a concrete grid. Buying it confers grid_ownership + the listed player-code keys + the quota preset atomically. */
export type GridListing = {
    __typename?: 'GridListing';
    /** App the listing belongs to. */
    appId: Scalars['BigInt']['output'];
    /** Player-code keys conferred on purchase. */
    conferredPermissionKeys: Array<Scalars['String']['output']>;
    /** Store description. */
    description: Scalars['String']['output'];
    /** UUID of the grid listing. */
    gridListingId: Scalars['String']['output'];
    /** 'blueprint' or 'concrete'. */
    kind: Scalars['String']['output'];
    /** Display name. */
    name: Scalars['String']['output'];
    /** Price in cents. */
    priceCents: Scalars['Int']['output'];
    /** Resale policy for the grid. */
    resalePolicy: Scalars['String']['output'];
    /** Catalog status: 'active' or 'delisted'. */
    status: Maybe<Scalars['String']['output']>;
    /** Studio cut (bps) on resale, when applicable. */
    studioCutBps: Maybe<Scalars['Int']['output']>;
};
/** Kind of principal holding grid title. P1 can assign USER owners; GROUP and ORG are schema-reserved for future shared ownership. */
export declare enum GridOwnerKind {
    Group = "GROUP",
    Org = "ORG",
    User = "USER"
}
/** The current first-class ownership record for a grid. Server player code always resolves its execution identity from this record. */
export type GridOwnership = {
    __typename?: 'GridOwnership';
    /** When this ownership began. */
    acquiredAt: Scalars['DateTime']['output'];
    /** Audit origin of this ownership (for example studio_grant, self_claim, self_claim_chunk, transfer, or marketplace). self_claim_chunk identifies a grid created by claimGridChunk and eligible for owner release. */
    acquiredVia: Scalars['String']['output'];
    /** App that contains the grid. */
    appId: Scalars['BigInt']['output'];
    /** Rental expiry; null for permanent ownership. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** Owned grid id. */
    gridId: Scalars['BigInt']['output'];
    /** UUID of the ownership history row. */
    gridOwnershipId: Scalars['String']['output'];
    /** Kind of current owner. P1 supports USER. */
    ownerKind: GridOwnerKind;
    /** Numeric user/group/org id selected by ownerKind. */
    ownerRef: Scalars['BigInt']['output'];
    /** Permanent ownership or an expiring rental. */
    tenure: GridTenure;
};
/** The permission-key whitelist configured for a grid (the grid_permission_limits input table). */
export type GridPermissionLimits = {
    __typename?: 'GridPermissionLimits';
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['output'];
    /** The grid the limits apply to. */
    gridId: Scalars['BigInt']['output'];
    /** The permission keys this grid is limited to. Empty means no limit (every active grid permission is allowed). */
    permissionKeys: Array<Scalars['String']['output']>;
};
/** Result of purchasing a grid listing: the owned grid the buyer now holds. */
export type GridPurchaseResult = {
    __typename?: 'GridPurchaseResult';
    /** The grid the buyer now owns. */
    gridId: Scalars['BigInt']['output'];
    /** True when ownership was assigned. */
    ownershipAssigned: Scalars['Boolean']['output'];
};
/** Whether the current title is permanent ownership or an expiring rental. */
export declare enum GridTenure {
    Owned = "OWNED",
    Rented = "RENTED"
}
/** A user's effective (materialized) runtime permissions on one grid: the flattened union of direct + group grants, with expired grants excluded, that Buddy enforces. */
export type GridUserPermissions = {
    __typename?: 'GridUserPermissions';
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['output'];
    /** The grid these permissions apply to. */
    gridId: Scalars['BigInt']['output'];
    /** The effective runtime permission key strings the user currently holds on this grid. */
    permissionKeys: Array<Scalars['String']['output']>;
    /** The user these permissions belong to. */
    userId: Scalars['BigInt']['output'];
};
/** A generic group. `groupType` discriminates teams ('team'), channels ('channel'), and grid-access groups ('grid'). */
export type Group = {
    __typename?: 'Group';
    /** The app (tenant) the group belongs to. */
    appId: Scalars['BigInt']['output'];
    /** When the group was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional role auto-assigned to every new member (e.g. a channel "member" role granting send_messages). Null means new members get no role by default. */
    defaultRoleId: Maybe<Scalars['BigInt']['output']>;
    /** Optional free-text description. */
    description: Maybe<Scalars['String']['output']>;
    /** Unique group id. */
    groupId: Scalars['BigInt']['output'];
    /** Discriminator: 'team' | 'channel' | 'grid'. */
    groupType: Scalars['String']['output'];
    /** How users may join: open (join immediately) | request (pending approval) | invite | admin. */
    membershipPolicy: Scalars['String']['output'];
    /** Display name (unique per app + group type). */
    name: Scalars['String']['output'];
    /** The user who created/owns the group (holds the system 'leader' role). */
    ownerUserId: Maybe<Scalars['BigInt']['output']>;
    /** Lifecycle status, e.g. 'active'. */
    status: Scalars['String']['output'];
};
/** A user's membership in a group, including the roles assigned to them. */
export type GroupMember = {
    __typename?: 'GroupMember';
    /** When the membership row was created. */
    createdAt: Scalars['DateTime']['output'];
    /** The group this membership is in. */
    groupId: Scalars['BigInt']['output'];
    /** Unique membership id. */
    groupMemberId: Scalars['BigInt']['output'];
    /** Roles assigned to this member. */
    roles: Array<GroupRole>;
    /** Membership status: 'active' | 'pending' (awaiting approval) | 'banned'. */
    status: Scalars['String']['output'];
    /** The member user id. */
    userId: Scalars['BigInt']['output'];
};
/** The caller's view of a group they belong to: the group, their roles, and their effective group permission keys. */
export type GroupMembership = {
    __typename?: 'GroupMembership';
    /** The group the caller belongs to. */
    group: Group;
    /** When the caller joined the group. */
    joinedAt: Scalars['DateTime']['output'];
    /** The caller's effective group permission key strings (union across their roles). */
    permissions: Array<Scalars['String']['output']>;
    /** The caller's roles in this group. */
    roles: Array<GroupRole>;
};
/** A role within a group (team/channel). Carries the group-management permission keys it grants (e.g. manage_members), NOT world/runtime grid permissions. */
export type GroupRole = {
    __typename?: 'GroupRole';
    /** When the role was created. */
    createdAt: Scalars['DateTime']['output'];
    /** The group this role belongs to. */
    groupId: Scalars['BigInt']['output'];
    /** Unique role id. */
    groupRoleId: Scalars['BigInt']['output'];
    /** True for built-in roles (e.g. 'leader') that cannot be renamed, re-ranked, or deleted. */
    isSystem: Scalars['Boolean']['output'];
    /** Group permission key strings this role grants (e.g. manage_members, manage_roles, manage_group, send_messages). */
    permissions: Array<Scalars['String']['output']>;
    /** Sort/precedence rank; higher is more senior. */
    rank: Scalars['Int']['output'];
    /** Role display name (unique within the group). */
    roleName: Scalars['String']['output'];
};
/** Copy a private library revision or immutable published common version into a project by value. */
export type ImportCrowdyStudioProjectFileInput = {
    /** App tenant shared by the project and import source. */
    appId: Scalars['BigInt']['input'];
    /** Immutable common version UUID; required only for COMMON imports. */
    commonVersionId?: InputMaybe<Scalars['String']['input']>;
    /** Optional safe destination path. Omit to use the source entry’s path or path hint. */
    destinationPath?: InputMaybe<Scalars['String']['input']>;
    /** Current project revision; the copy and revision increment are atomic. */
    expectedProjectRevision: Scalars['BigInt']['input'];
    /** Optional 24-hour retry key. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Caller-owned library file UUID; required only for LIBRARY imports. */
    libraryFileId?: InputMaybe<Scalars['String']['input']>;
    /** Destination project UUID. */
    projectId: Scalars['String']['input'];
    /** Private LIBRARY or app-curated COMMON source. */
    source: CrowdyStudioImportSource;
};
export type InviteOrgMemberInput = {
    /** Organization to add the user to (BigInt as string). */
    orgId: Scalars['BigInt']['input'];
    /** user_id of the user to add (BigInt as string). */
    userId: Scalars['BigInt']['input'];
};
/** Invoke a studio-defined function against a self container. */
export type InvokeFunctionInput = {
    /** The app (tenant) that owns the function. */
    appId: Scalars['BigInt']['input'];
    /** The function name to invoke. */
    functionName: Scalars['String']['input'];
    /** JSON object of params. */
    paramsJson?: InputMaybe<Scalars['String']['input']>;
    /** The 'self' container the function runs against (referenced as self in expressions). */
    selfContainerId: Scalars['String']['input'];
    /** Optional session context for the invocation. */
    sessionId?: InputMaybe<Scalars['String']['input']>;
};
/** Join an existing session. */
export type JoinSessionInput = {
    /** The app (tenant) that owns the session. */
    appId: Scalars['BigInt']['input'];
    /** Optional participant role to join as. */
    role?: InputMaybe<Scalars['String']['input']>;
    /** The session id to join. */
    sessionId: Scalars['String']['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). */
    appId: Scalars['BigInt']['input'];
    /** Center chunk of the search cube. */
    centerCoordinate: ChunkCoordinatesInput;
    /** Maximum number of CHUNKS (not voxels) to include. Defaults to 1000 when omitted. Must be >= 0. */
    limit?: InputMaybe<Scalars['Int']['input']>;
    /** Cube radius in chunks measured as Chebyshev distance: matches chunks whose x, y and z each differ from the center by at most this many chunks. Integer, 1-8 inclusive. */
    maxDistance: Scalars['Int']['input'];
    /** Optional inclusive lower time bound; only edits with createdAt >= this timestamp are returned. */
    since?: InputMaybe<Scalars['DateTime']['input']>;
    /** Number of chunks to skip for pagination. Defaults to 0 when omitted. Must be >= 0. */
    skip?: InputMaybe<Scalars['Int']['input']>;
};
/** Arguments for listVoxels: selects recorded voxel edits for one chunk, optionally only those at/after a timestamp. */
export type ListVoxelsInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk whose voxel edits to list. */
    coordinates: ChunkCoordinatesInput;
    /** Optional inclusive lower time bound. When set, only voxel edits with createdAt >= this timestamp are returned. */
    since?: InputMaybe<Scalars['DateTime']['input']>;
};
/** A single level-of-detail (LOD) representation of a chunk. */
export type LodData = {
    __typename?: 'LodData';
    /** BASE64-encoded binary LOD data (decode from base64). */
    data: Scalars['String']['output'];
    /** LOD level (0 is the finest; higher numbers are coarser). */
    level: Scalars['Int']['output'];
};
/** A single LOD level and its encoded data for a chunk. */
export type LodDataInput = {
    /** BASE64-encoded binary LOD data for this level. */
    data: Scalars['String']['input'];
    /** LOD level (>= 0; 0 is the finest / highest detail). */
    level: Scalars['Int']['input'];
};
export type LoginUserInput = {
    /** Account email address. */
    email: Scalars['String']['input'];
    /** Account password (min 8 characters). */
    password: Scalars['String']['input'];
};
/** Which engine's meter produced a quantity of compute units. "expression" is the model expression engine (player invokes, automations and timers); "studio_wasm" is developer-authored compute modules; "player_wasm" is the player compute tier, which has its own tables and its own billed metric. */
export declare enum MeteredComputeEngine {
    /** The model expression engine: gameModelInvoke, automation runs and timer fires. */
    Expression = "EXPRESSION",
    /** Player-authored WASM compute. */
    PlayerWasm = "PLAYER_WASM",
    /** Developer-authored WASM compute modules. */
    StudioWasm = "STUDIO_WASM"
}
/** Input for mintAppToken: directly mint an app-scoped gameplay token for the calling user (native/direct path, no browser redirect). */
export type MintAppTokenInput = {
    /** Numeric id of the app to mint a confined gameplay token for. Free/open apps are auto-granted access; paid apps require an existing entitlement (else FORBIDDEN). */
    appId: Scalars['BigInt']['input'];
};
export type Mutation = {
    __typename?: 'Mutation';
    /** Acquire a free listing: writes the entitlement row (no payment edge exists in P4a — paid modes are P4b). Idempotent per (listing, caller). Allowed in any admission mode; in allow_list apps an unadmitted acquisition holds until the listing/author/org is admitted, at which point installPlayerCode proceeds. */
    acquirePlayerCode: PlayerCodeAcquisition;
    /** Application liveness heartbeat for the authenticated user's existing actor rows in an app. Refreshes actors.updated_at so the user stays host-eligible, then returns the freshly-elected host so a client can fold its poll and heartbeat into one round-trip. This is not proof of a live Buddy session and does not refresh the separate Buddy presence lease used by security-sensitive artifact/compute occupancy gates. */
    actorHeartbeat: Maybe<GameHost>;
    /** Add a user to a channel, or approve their pending join request (upsert to active). Requires the 'manage_members' channel permission (app admins bypass). Auto-assigns the default role if configured and notifies Buddy with the member's effective send permission. */
    addChannelMember: GroupMember;
    /** Add a user to a team, or approve their pending join request (upsert to active). Requires the 'manage_members' team permission (app admins bypass). Auto-assigns the team's default role if configured. */
    addTeamMember: GroupMember;
    /** Admit one player-code listing, author, or authoring org to an app's strict allow list. Requires 'manage_compute'. Idempotency is explicit: an identical active entry returns a conflict instead of silently creating duplicates. SIDE EFFECTS: audit row + replica sync. */
    admitAppCode: AppCodeAdmission;
    /** Soft-delete an access tier by setting its status to 'archived' (the row is retained, NOT hard-deleted) and notifies the game API. Requires the 'manage_access_tiers' permission on the app that owns the tier; super admins bypass. Existing user grants on this tier are NOT automatically revoked. Throws if the tier is not found. */
    archiveAccessTier: AppAccessTier;
    /** Soft-delete an app by setting status=ARCHIVED. The row is retained (NOT hard-deleted) and is excluded from the public marketplace. REVERSIBLE: call updateApp to set status back to DRAFT or LIVE. Requires the 'manage_apps' permission on the app; super admins bypass. Throws if the app id does not exist. */
    archiveApp: App;
    /** Assign first-class title for an unowned grid to one user. P1 studio/bootstrap path; marketplace acquisition supersedes it later. Requires app-admin ('manage_apps'). Assigns title only: permissions must be granted explicitly. */
    assignGridOwnership: GridOwnership;
    /** 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;
    /** Begin Stripe Connect Express onboarding for an ORG's payout account (org-owned listings, DN-9). Requires 'manage_billing' in the org. */
    beginOrgSellerOnboarding: SellerOnboardingLink;
    /** Begin vaulting a card on the caller's player wallet (P4b): returns a Stripe SetupIntent client secret + publishable key for the browser to confirm. On success the card is saved for wallet auto-recharge and rent auto-renew. Closes the P2 gap where players had no card-setup path. */
    beginPlayerCardSetup: PlayerCardSetup;
    /** Begin Stripe Connect Express seller onboarding for the calling player (personal listings). Returns the hosted onboarding URL to finish KYC, or an unavailable reason in unsupported regions. Required before pricing a listing above free. */
    beginSellerOnboarding: SellerOnboardingLink;
    /** 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. */
    capturePaypalCheckout: Checkout;
    /** Changes the authenticated user's password after verifying the current password. Requires a valid session token. Returns true on success; throws if the current password is wrong. Existing sessions are not revoked. */
    changePassword: Scalars['Boolean']['output'];
    /** Self-service: the authenticated caller claims access to an app via its free, open-by-default tier. Requires authentication only (no org membership needed). ENTITLEMENT CHANGE: grants the free default tier as a 'system' grant and notifies the game API. Idempotent: returns the existing row if already granted, and never overrides a prior revoke. Errors if the app has no free default tier or is archived. */
    claimFreeAppAccess: AppUserAccess;
    /** Claim one currently unclaimed chunk as a new player-owned grid. Requires an ordinary app-scoped player token and active app access, but never manage_apps. The app's policy must be SELF_CLAIM. The server validates the app's grid assignment and peer-overlap rules, then atomically creates a one-chunk grid, assigns current-user ownership, grants access/update_voxel_data/use_voice_chat/teleport plus player-code keys already carried by the caller's tier, and materializes the effective ACL. Conflicts and policy denials throw GraphQL errors; no partial grid, ownership, or grant rows remain. */
    claimGridChunk: ChunkClaimResult;
    /** Claim grid ownership under the app's claim policy (D4, server-authorized — no client manage_apps involved). SELF_CLAIM assigns ownership immediately; APPROVAL creates a pending request for designated approvers; INVITE requires a standing invite (consumed on use); MARKETPLACE_ONLY refuses (ownership arrives only via grid purchase, P4b). The grid must exist and have no current owner; game rules gate who may attempt a claim. */
    claimGridOwnership: GridClaimResult;
    /** Remove an app's compute allowance, returning it to observation against the platform reference allowance. Returns true if an allowance was removed. Requires app-admin ('manage_apps'). */
    clearAppComputeBudget: Scalars['Boolean']['output'];
    /** 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;
    /** Delete a compute module and (via cascade) its versions, triggers, and lease. Run history is retained for auditing. Returns true when a module was deleted. Requires the org 'manage_compute' permission. */
    computeDeleteModule: Scalars['Boolean']['output'];
    /** Delete a compute-module trigger by id. Returns true when a trigger was deleted. Requires the org 'manage_compute' permission. */
    computeDeleteTrigger: Scalars['Boolean']['output'];
    /** Deploy a named engine template from the platform registry: upserts the module, publishes the template source (deduped by hash), binds its triggers, and enables it — one call instead of the upsert/deploy/trigger/enable sequence. Compilation proceeds asynchronously; poll computeModuleVersions for compile status. Templates are data-driven (behavior comes from model containers such as MobDef/EncounterDef/Course), so most games parameterize rather than fork. Requires the org 'manage_compute' permission. */
    computeDeployTemplate: WasmModule;
    /** Upload a new immutable source version of a compute module and make it the deployed version. The source map is validated (Cargo.toml + src/*.rs only, size caps, platform crate allowlist, no build-time code) and parked as compile_status=pending; a game-api instance compiles it before it can run. Requires the org 'manage_compute' permission. */
    computeDeployVersion: WasmModuleVersion;
    /** Invoke a compute module's client-callable export (a trigger with triggerType=invoke). Synchronous RPC: the module runs and returns its result directly (unlike the spatial send surface's dual-success model). Authorization: the export's invoke policy (authority tree) — or holders of 'manage_compute' only when no policy is set. Requires a valid app token. */
    computeInvoke: ComputeInvokeResult;
    /** Restart a module that was stopped for exceeding a resource limit, without deploying a new version. Deploying a fix clears the stop on its own and is the normal path; use this when the limit itself was wrong or the load is being accepted deliberately. The reason is recorded. Requires the org 'manage_compute' permission. */
    computeResetBreaker: WasmModule;
    /** Enable or disable a compute module. Enabling requires a deployed version and resets the module's circuit breaker; disabling stops all scheduling. Requires the org 'manage_compute' permission. */
    computeSetModuleEnabled: WasmModule;
    /** Set the app's compute policy (platform guardrails): the kill switch, module count / tick-rate / fuel / memory / runtime / host-op / egress ceilings, and circuit-breaker tuning. Omitted fields keep current values. Requires the org 'manage_compute' permission. */
    computeSetPolicy: WasmModulePolicy;
    /** Create or update a WASM compute module (metadata only). Modules hold developer-authored Rust compiled to sandboxed WASM on game-api instances; upload source with computeDeployVersion. New modules start disabled. Upsert key is (app, name). Requires the org 'manage_compute' permission. */
    computeUpsertModule: WasmModule;
    /** Bind a trigger to a compute module: a tick loop (tickHz, clamped by policy), an event subscription (model or compute events), or a client-invokable export (with an optional invoke policy). Requires the org 'manage_compute' permission. */
    computeUpsertTrigger: WasmModuleTrigger;
    /** 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;
    /** Consent to run a grid-attached client mod (D2): acknowledges the attachment's exact capability hash. A newer version with a widened summary carries a different hash, so stale consents fail closed — re-consent is always explicit. Consent is per player per attachment. */
    consentGridClientMod: Scalars['Boolean']['output'];
    /** Operator only (is_operator). Patches the platform compute ceilings: omitted fields stay unchanged, an explicit null clears that override (game-api falls back to env/default), a value (> 0) sets it. SIDE EFFECTS: fans a replica notify out to every game-api so the new ceilings clamp computeSetPolicy within ~30 seconds without a restart, and writes an audit entry. Lowering a ceiling does not shrink already-stored per-app policies; it rejects future computeSetPolicy values above the new ceiling. Returns the updated ceilings row. */
    cpSetComputePlatformCeilings: CpComputePlatformCeilings;
    /** Operator only (is_operator or is_super_admin). Publish or release an emergency kill for one app. This state is separate from the app's own kill and always takes precedence in Management's effective envelope; app users cannot clear it. SIDE EFFECTS: revision increment and a sanitized audit event. NOTHING IS PUSHED TO GAME API: preemption takes effect when its runtime next pulls this app's crowdy.studio-agent-policy/1 replica, which is within about a minute for an app already holding one and not at all for an app that does not until a permitted caller asks. Releasing the operator kill does not enable the app or clear its own kill. Stable errors: AGENT_POLICY_INVALID, AGENT_POLICY_REVISION_CONFLICT, IDEMPOTENCY_CONFLICT. */
    cpSetCrowdyStudioAgentAppKill: CrowdyStudioAgentPolicy;
    /** Operator only (is_operator or is_super_admin). Patch Management platform Agentic Studio policy and global emergency kill. SIDE EFFECTS: the published kill takes precedence over every app setting, the revision increments, and a sanitized append-only audit event is written. NOTHING IS FANNED OUT TO APPS: Game API pulls crowdy.studio-agent-policy/1 per app, so a platform change reaches an app that already holds a replica within about a minute (refreshAfter is two thirds of a 60s validity) and reaches an app with no replica only when a permitted caller next asks about it. Game API must fail closed if the envelope is missing, malformed, or stale. Narrowing the platform lists narrows every app immediately on its next read, including apps that expressed no narrowing of their own. Hard ZDR/collection/body-retention rules and platform-funded/no-wallet pilot funding cannot be loosened. Stable errors: AGENT_POLICY_INVALID, AGENT_POLICY_REVISION_CONFLICT, IDEMPOTENCY_CONFLICT. */
    cpSetCrowdyStudioAgentPlatformPolicy: CrowdyStudioAgentPolicy;
    /** Create a new access tier (a free/paid bundle of runtime permissions) for an app. Requires the 'manage_access_tiers' permission on the app (input.appId); super admins bypass. SIDE EFFECTS: validates the tier's permission keys against runtimePermissions and notifies the game API so Buddy sees the new tier. Does NOT grant the tier to any user. */
    createAccessTier: AppAccessTier;
    /** Creates an actor (a player’s presence/instance in an app world) owned by the authenticated user and returns the persisted row (including the server-set `createdAt`). Requires a valid game token. If `input.avatarId` is set it must reference an avatar the caller owns (throws Unauthorized otherwise). `input.uuid` must be the 32-character ASCII actor id used on the UDP wire (NOT a hyphenated RFC-4122 UUID). */
    createActor: Actor;
    /** Create a new app within an organization. Requires the 'manage_apps' permission on the target org (input.orgId); super admins bypass. REQUIRES A DATACENTER (input.datacenter): the app is distributed on its app_id, so all of its data lives in one datacenter, and the id is chosen at creation so that it does. Query placeableDatacenters first for the codes this deployment accepts. Creation FAILS — rather than producing an unroutable app — if the named datacenter is unknown to this deployment or holds no shards. SIDE EFFECTS: also provisions a free, open-by-default "Default" access tier granting baseline runtime permissions and notifies the game API. Elevated capabilities such as use_studio_agent are NOT granted by default and require an explicit tier grant. Slug must be unique within the org (a duplicate slug fails). New apps default to visibility=PUBLIC and status=DRAFT unless overridden in the input. */
    createApp: App;
    /** Creates a new avatar owned by the authenticated user and returns it. Requires a valid game token; the new avatar is always owned by the caller. `input.name` is optional and defaults to "Default Avatar". */
    createAvatar: Avatar;
    /** Create a channel. Whether the caller may create one is governed by the per-app channel policy (app_group_policies: admin | member | anyone). The caller becomes the owner with a system 'leader' role. When membersCanSend is true (default) a default 'member' role granting send_messages is created and auto-assigned to joiners (open chat channel); when false only roles you grant may post (announce/read-only channel). */
    createChannel: Group;
    /** Create a custom (non-system) channel role granting the given channel permission keys (e.g. send_messages for posting rights). Requires the 'manage_roles' channel permission (app admins bypass). */
    createChannelRole: GroupRole;
    /** Creates a Checkout row, opens a hosted payment session with the selected provider, and returns the row with `externalUrl` set — redirect the user there to pay. Status starts PENDING and is reconciled to COMPLETED/FAILED later via provider webhooks (this call does not itself capture funds). The side effect applied on completion depends on `purpose` (e.g. ORG_WALLET_TOPUP credits the org wallet, APP_ACCESS_PURCHASE grants app access). Requires an authenticated user; ORG_WALLET_TOPUP additionally requires the 'manage_billing' org permission. Purposes DONATION and PROPERTY_TOKENS are rejected. Pass `input.idempotencyKey` to make retries safe (a replay returns the first checkout instead of opening a second provider session). */
    createCheckout: Checkout;
    /** Create a grid: a named 3D box of chunks that runtime/world (voxel) permissions are scoped to. The box must fit within one of the app's grid assignments (its buildable regions); it MAY be nested inside a broader containing grid such as the open-by-default world grid, but must not partially overlap a peer grid. Requires app-admin ('manage_apps'). Returns a hybrid response — on success `grid` is populated and `error` is NO_ERROR; on failure `grid` is null and `error` is a UDP-style error code (e.g. NO_MATCHING_GRID_ASSIGNMENT, GRID_OUTSIDE_ASSIGNMENT, GRID_OVERLAPS_EXISTING, GRID_ALREADY_EXISTS). */
    createGrid: CreateGridResponse;
    /** Create a studio grid listing (07 §1.1): a blueprint that stamps a fresh grid per sale, or a concrete grid. Requires 'manage_apps'. Purchase (in-game) confers grid_ownership + the listed keys + quota preset atomically. */
    createGridListing: GridListing;
    /** Creates a custom role in an organization with a name, optional description, and permission keys. Requires the 'manage_members' permission on the org (super admins bypass). */
    createOrgRole: OrgRole;
    /** Create an embedded-components Account Session for an ORG's payout account (org-owned listings, DN-9). Requires 'manage_billing' in the org. */
    createOrgSellerAccountSession: SellerAccountSession;
    /** Mints a new org API token and returns the plaintext token exactly once - save it, since subsequent queries only show metadata. Requires the 'manage_tokens' permission on the target org (super admins bypass). */
    createOrgToken: OrgTokenWithSecret;
    /** Creates a new organization and makes the authenticated caller its owner (with full permissions). Requires a valid session token. */
    createOrganization: Organization;
    /** Create a one-time, PKCE-bound portal authorization code (browser handoff). The Overworld identity origin (holding the SESSION token) calls this; redirect the player to the destination game carrying the code, which the game exchanges via exchangePortalCode. Requires a SESSION token. */
    createPortalAuthorizationCode: PortalAuthorizationCode;
    /** Create an Account Session for Stripe's EMBEDDED Connect components on the calling player's seller account (created on first call): the browser initializes Connect.js with the returned publishable key + client secret and mounts account-onboarding / payouts / balances INSIDE the platform UI. Client secrets are short-lived — re-request on expiry. The hosted-link flow (beginSellerOnboarding) remains the fallback. */
    createSellerAccountSession: SellerAccountSession;
    /** Create a team. Whether the caller may create one is governed by the per-app team policy (app_group_policies: admin | member | anyone). The caller becomes the owner and is granted a system 'leader' role holding every team permission. New teams default to the app's default membership policy unless overridden. */
    createTeam: Group;
    /** Create a custom (non-system) team role granting the given team permission keys. Requires the 'manage_roles' team permission (app admins bypass). Permission keys must be valid team permission keys (group_permission_defs). */
    createTeamRole: GroupRole;
    /** OPERATOR ONLY. Credits an organization wallet without a payment provider, for seeding a test environment or making an operator adjustment, and records it in the wallet ledger as an "admin_credit" transaction. Use this instead of writing to org_wallets by hand: it creates the wallet if absent, repairs a missing wallet id, and moves the balance and the ledger row together in one transaction. Pass a referenceId to make retries idempotent. SIDE EFFECT: re-evaluates the runtime gate for every shared app in the org, so a credit that clears an insufficient_funds denial lifts it immediately instead of leaving the app refusing clients. */
    creditOrgWallet: WalletTransaction;
    /** Monotonically persist one attached epoch’s highest contiguous applied event sequence. Requires the app-scoped owner, exact current epoch, and idempotency key; stale epochs and gaps fail with stable errors. */
    crowdyStudioAgentAcknowledgeEvents: AgentEventAcknowledgement;
    /** Human-grant one unexpired pending tool call by exact argument hash. The server revalidates epoch, context, policy, lease, descriptor, permissions, and project revision before single-use consumption. Requires the app-scoped owner, use_studio_agent, and idempotency key; approval never creates missing authority. */
    crowdyStudioAgentApproveTool: AgentApproval;
    /** Attach one interactive browser, allocate a new monotonic epoch, return that client instance’s replay cursor, and fence every older epoch plus its leases, approvals, and pending browser tools. Requires the app-scoped owner, use_studio_agent, and idempotency key; reconnect never replays an effect. */
    crowdyStudioAgentAttachClient: AgentClientAttachment;
    /** Immediately make one owner/session run durably CANCELLED, revoke pending capabilities/tools, and abort its local provider stream when present. Requires the app-scoped owner, current epoch, exact run id, and idempotency key; cancellation never silently resumes. */
    crowdyStudioAgentCancelRun: AgentRun;
    /** Permanently close one owner/app session, preempt its active run, revoke leases/approvals/dispatches, detach clients, and start the 30-day agent-data cleanup clock without deleting canonical projects/runtime state. Requires the current epoch and idempotency key. */
    crowdyStudioAgentCloseSession: AgentSession;
    /** Create a durable owner/app Agentic Crowdy Studio session and pin mode, private project/grid context, allowlisted model, exact Management platform/app revisions, and the mode/tool/risk-filtered registry digest. Requires an app-scoped token, use_studio_agent, a fresh non-killed policy, and an idempotency key; optional consent applies only to private source. */
    crowdyStudioAgentCreateSession: AgentSession;
    /** Human-grant a visible PLAY lease with explicit scopes, controlled entity, host capability revision, epoch, context, and 1–600 second duration. Requires PLAY mode, selected grid, app-scoped owner, use_studio_agent, effective policy, and idempotency key; the model cannot grant or renew it. */
    crowdyStudioAgentGrantLease: AgentLease;
    /** Recheck current agent permission, policy, owner context, and record the attached heartbeat. CrowdyJS sends this every two seconds; PLAY is stale after five seconds and an unchanged workspace lease renews to 30 seconds. Requires the current app-scoped owner/epoch and an idempotency key. */
    crowdyStudioAgentHeartbeat: AgentHeartbeat;
    /** Immediately pause the session and active run, revoke leases/approvals/pending dispatches, and persist SESSION_PAUSED. This human safety action does not wait for provider progress; requires the app-scoped owner, current epoch, and idempotency key. */
    crowdyStudioAgentPause: AgentSession;
    /** Human-deny one unexpired pending exact tool call, terminally denying the call and failing its run without any effect. Requires the app-scoped owner, current epoch, matching hash, and idempotency key. */
    crowdyStudioAgentRejectTool: AgentApproval;
    /** Explicitly resume a paused session after fresh policy/context validation and requeue its paused run. PLAY never restores an old lease. Requires the app-scoped owner, current epoch, use_studio_agent, and idempotency key. */
    crowdyStudioAgentResume: AgentSession;
    /** Immediately and idempotently revoke one owner/session lease. This safety action remains available without waiting for provider/model progress and does not require approval; requires an app-scoped owner, current epoch, and idempotency key. */
    crowdyStudioAgentRevokeLease: AgentLease;
    /** Append one bounded, redacted human message and queue exactly one serialized provider/tool run. Requires an active app-scoped owner, use_studio_agent, current epoch, fresh Management policy, complete budget reservation, and idempotency key; private source remains separately policy/consent gated. */
    crowdyStudioAgentSendMessage: AgentRun;
    /** Atomically human-select ASK, BUILD, or PLAY plus optional project/grid and repin effective policy revisions, descriptors, registry digest, and context. The change preempts runs and revokes old leases/approvals. Requires current epoch, app owner, use_studio_agent, mode policy, and idempotency key. */
    crowdyStudioAgentSetMode: AgentSession;
    /** Submit one idempotent terminal result for a matching BROWSER dispatch. The server fences old epochs/context, validates output against the pinned descriptor, redacts before persistence/provider continuation, and never retries OUTCOME_UNKNOWN. Requires an app-scoped owner and idempotency key. */
    crowdyStudioAgentToolResult: AgentToolCall;
    /** Publish a new immutable version of an app-scoped Crowdy Studio-curated common file and make it the current player-readable version. Requires an app-scoped token plus the app manage_compute permission. Old versions remain immutable for provenance; an idempotency key is strongly recommended for transport retries. */
    crowdyStudioCommonPublish: CrowdyStudioCommonFile;
    /** Create or optimistically update one private personal-library source file. Requires an app-scoped token; ownership is always the authenticated player and cannot be delegated. Safe source paths, 64-KiB content, revision, and configurable bounded aggregate library storage are enforced atomically. */
    crowdyStudioLibrarySave: CrowdyStudioLibraryFile;
    /** Archive or restore one caller-owned personal-library file under optimistic revision control. Requires an app-scoped token and exact app/user ownership; archived entries remain retained but cannot be imported until restored. */
    crowdyStudioLibrarySetArchived: CrowdyStudioLibraryFile;
    /** Create a private revisioned Crowdy Studio project for the authenticated player, optionally with initial server/client text files. Requires only an app-scoped token for the input app; optional grid affinity is validated but grants no deployment authority. Source paths, per-target deploy caps, and aggregate owner/app storage are enforced atomically. */
    crowdyStudioProjectCreate: CrowdyStudioProject;
    /** Lazily create a private project by copying the authenticated author’s latest source from an existing self-authored SERVER module, CLIENT module, or both. Requires an app-scoped token and authorship of every requested module; current grid ownership is deliberately not required for private source recovery after transfer, while any later deploy still rechecks ownership and target permissions. Repeated requests reuse the matching active project. */
    crowdyStudioProjectCreateFromModules: CrowdyStudioProject;
    /** Copy one active caller-owned library revision or one immutable published app-common version into a private project by value. Requires an app-scoped token and exact project ownership. The source is re-authorized, content/provenance are snapshotted, project caps and aggregate storage are checked, and the project revision advances atomically. */
    crowdyStudioProjectImportFile: CrowdyStudioProject;
    /** Atomically save selected private project metadata and a batch of file upserts/deletes under one expected project revision. Requires an app-scoped token and exact project ownership. No partial metadata or file changes survive validation, target-cap, aggregate-storage, module-binding, or revision failures. */
    crowdyStudioProjectSave: CrowdyStudioProject;
    /** Apply a batch of project-file upserts and deletes in one transaction under one expected project revision. Requires an app-scoped token and exact project ownership. No partial writes survive path, manifest, independent 8-file/64-KiB-file/256-KiB-target caps, aggregate storage, or revision failures. */
    crowdyStudioProjectSaveFiles: CrowdyStudioProject;
    /** Optimistically save selected private project metadata and increment its monotonic revision. Requires an app-scoped token and exact project ownership. A stale expectedRevision returns CONFLICT; grid affinity remains an authoring hint and never bypasses player-compute deployment checks. */
    crowdyStudioProjectSaveMetadata: CrowdyStudioProject;
    /** Archive or restore a private project without deleting any source or provenance, using optimistic revision control. Requires an app-scoped token and exact owner match. Archived projects remain readable by their owner but are read-only until restored. */
    crowdyStudioProjectSetArchived: CrowdyStudioProject;
    /** Release (settle held order + unfreeze payout) or confirm (uphold) a T11 risk flag. Requires 'manage_compute'. */
    decideCommerceRiskFlag: Scalars['Boolean']['output'];
    /** Approve or deny a pending grid claim request (claim policy APPROVAL). Callable by the app's designated approver users or studio staff holding manage_compute. Approval assigns grid_ownership to the requester. */
    decideGridClaim: GridClaimRequest;
    /** DESTRUCTIVE: permanently deletes the actor identified by `uuid` and returns a copy of the now-deleted row. OWNER-EXCLUSIVE: only the owner may delete (throws Unauthorized otherwise). Requires a valid game token. `uuid` is the 32-character ASCII actor id. */
    deleteActor: Actor;
    /** DESTRUCTIVE: permanently deletes the avatar and returns a copy of the now-deleted row. OWNER-EXCLUSIVE: only the owner may delete (throws Unauthorized otherwise). Requires a valid game token. */
    deleteAvatar: Avatar;
    /** Delete a channel. Requires the 'manage_group' channel permission (app admins bypass). DESTRUCTIVE: cascades to members and roles and notifies Buddy servers to tear down message routing for the channel. Returns true on success. */
    deleteChannel: Scalars['Boolean']['output'];
    /** Delete a non-system channel role. Requires the 'manage_roles' channel permission (app admins bypass). The system 'leader' role cannot be deleted. DESTRUCTIVE: removes the role from members. Returns true if a role was deleted. */
    deleteChannelRole: Scalars['Boolean']['output'];
    /** Delete a studio-created peer grid so its chunk box no longer blocks overlapping grid creation. Requires app-admin ('manage_apps'). Returns a hybrid response — on success `gridId` is populated and `error` is NO_ERROR; on failure `gridId` is null and `error` is a UDP-style error code (e.g. GRID_NOT_FOUND, CANNOT_DELETE_DEFAULT_WORLD_GRID, GRID_HAS_NESTED_CHILDREN). The open-by-default world grid and any grid that still contains nested child grids cannot be deleted. */
    deleteGrid: DeleteGridResponse;
    /** DESTRUCTIVE self-service: soft-deletes the authenticated caller's OWN account — anonymizes PII and revokes all sessions; wallet, voxel, and donation history stay intact via FK. Acts only on the caller (no target argument). Requires a valid game token. */
    deleteMyAccount: Scalars['Boolean']['output'];
    /** Deletes an organization role. Requires the 'manage_members' permission on the role's org (super admins bypass). DESTRUCTIVE: removes the role and unassigns it from all members. Returns false if the role does not exist. */
    deleteOrgRole: Scalars['Boolean']['output'];
    /** Delete a player-compute policy row; covered players fall back to the next most general scope. Returns false when no matching row exists. Requires 'manage_compute'. */
    deletePlayerWasmPolicy: Scalars['Boolean']['output'];
    /** Permanently deletes a quota enforcement rule by id. Returns true if a rule was removed, or false if no quota with that id exists. Destructive and not reversible: once removed, the metric falls back to the next-most-specific rule or the free-tier default. Requires the 'manage_quotas' permission on the same scope (app or org) the quota belongs to, or super admin for global quotas. */
    deleteQuota: Scalars['Boolean']['output'];
    /** Delete a team. Requires the 'manage_group' team permission (app admins bypass). DESTRUCTIVE: cascades to members, roles, and any grid grants the team conferred, and recomputes the effective grid ACL for affected grids. Returns true on success. */
    deleteTeam: Scalars['Boolean']['output'];
    /** Delete a non-system team role. Requires the 'manage_roles' team permission (app admins bypass). The system 'leader' role cannot be deleted. DESTRUCTIVE: removes the role from members and recomputes any grid ACLs the role granted on. Returns true if a role was deleted. */
    deleteTeamRole: Scalars['Boolean']['output'];
    /** DESTRUCTIVE: deletes the authenticated user’s per-app state row for `appId` and returns the deleted row. Requires a valid game token; acts only on the caller’s own state. Throws NotFound when no row exists. */
    deleteUserAppState: UserAppState;
    /** 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. */
    exchangePortalCode: AppTokenResponse;
    /** ADMIN/DESTRUCTIVE: revokes ALL of the target user’s sessions by deleting every game_token row, forcing re-authentication on every device. Returns true if at least one session was revoked. Requires a super-admin bearer game token (and the management API enabled). */
    forceLogoutUser: Scalars['Boolean']['output'];
    /** Operator only (is_operator). Deletes the stored deliverability rows for one address (email_status and email_events) and returns how many rows went. Exists so a verification run is not reading the previous run's events, and so an address suppressed by a bounce that has since been fixed can be given another chance. Returns 0 when there was nothing stored. */
    forgetEmailDeliverability: Scalars['Int']['output'];
    /** Create a directed relationship edge between two containers (the game model is a graph), with a relationship type and optional weight. Requires a valid token. */
    gameModelAddEdge: GmEdge;
    /** Cancel pending timers by id or by dedupe key, returning how many were removed. A timer already claimed for execution cannot be cancelled. Requires app-admin ('manage_apps'). */
    gameModelCancelTimer: Scalars['Int']['output'];
    /** Instantiate a container (a runtime entity of a given type), optionally within a session, with an owner and initial properties. Subject to the type's instantiableBy rule (admin | member | owner). Requires a valid token. */
    gameModelCreateContainer: GmContainer;
    /** 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. The caller becomes the creator and a participant. Requires a valid token. */
    gameModelCreateSession: GmSession;
    /** 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 (app, featureKey). Requires app-admin ('manage_apps'). */
    gameModelDefineFeature: GmAppFeature;
    /** Delete an automation by name (also removes its event triggers). Requires app-admin ('manage_apps'). DESTRUCTIVE. Returns true if one was deleted. */
    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'];
    /** Atomically get-or-create a container by an opaque bindingKey, unique per (appId, typeName, sessionId). Concurrent ensures with the same key all return the SAME containerId and exactly one response has created: true — no client-side leader election or list-then-create coordination is needed for shared world objects. When the row already exists this behaves like a read (creation-only fields are ignored and the type's instantiableBy rule is NOT enforced); when it does not exist, creation is authorized exactly like gameModelCreateContainer (instantiableBy + owner rules) AND by the type's bindPolicy, so a caller who may not instantiate the type, or may not claim keys for it, errors only in the not-exists case. bindingKey is client-supplied, so on a member- or owner-instantiable type ANY entitled player may create the keyed row and becomes its owner — which inverts every owner_of_self invoke policy on that type. Set the container type's bindPolicy (e.g. {"type":"is_host"}), or use an admin-instantiable type, for any object more than one player shares. Requires a valid token. */
    gameModelEnsureContainer: GmEnsureContainerResult;
    /** 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). Invoke-policy denials are gameplay verdicts, NOT exceptions: they return success=false with errorMessage and log a failure event (observable via gameModelEvents). Scope violations (calling a server-scope function as a non-admin, or an internal function directly) are misconfigurations and throw FORBIDDEN. This is the primary, safe way for players to mutate game state. Requires a valid token; only player-scope functions are invocable here. RATE LIMITED per player per app, defaulting to 120 invocations per 10 seconds: over the limit the call is refused with extensions.code RATE_LIMITED, extensions.blame 'budget' (the caller's own budget — not a fault in the game's code and not a platform failure) and extensions.retryAfterMs. A client that awaits each response cannot reach the limit, because the per-call ceiling already bounds a serial caller well below it. */
    gameModelInvoke: GmInvokeResult;
    /** Join an existing session as a participant, optionally with a role. Requires a valid token and app access. */
    gameModelJoinSession: GmSessionParticipant;
    /** Revoke a feature key from an access tier. Requires app-admin ('manage_apps'). Returns true if a grant was removed. */
    gameModelRevokeTierFeature: Scalars['Boolean']['output'];
    /** Run an automation once, immediately (manual trigger), regardless of its schedule. Applies the same guard chain (app gate, rate limit, circuit) and records a run. Useful for testing an NPC. Requires app-admin ('manage_apps'). */
    gameModelRunAutomation: GmAutomationRun;
    /** 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. The target function must be autonomousInvocable, because the fire is headless and runs with system authority rather than a player's — which is also why this needs app-admin ('manage_apps'). For player-driven delays, author a timers effect on a function instead so the delay is part of your game logic. Supply dedupeKey to make re-arming replace the pending timer rather than queue another fire. */
    gameModelScheduleInvoke: GmTimer;
    /** 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 app-admin ('manage_apps'). Returns counts created, warnings, and a map of seed temp_id -> created container UUID. */
    gameModelSeed: GmSeedResult;
    /** Enable or disable an automation. Re-enabling also resets its circuit breaker (closed, zero failures, no pause) so a tripped automation resumes. Requires app-admin ('manage_apps'). */
    gameModelSetAutomationEnabled: GmAutomation;
    /** 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, and the aggregate per-minute run ceiling. Requires app-admin ('manage_apps'). */
    gameModelSetAutomationPolicy: GmAutomationPolicy;
    /** Set the app's game-model runtime policy: who may create sessions (admin | member | anyone) and the default participant role. Requires app-admin ('manage_apps'). */
    gameModelSetPolicy: GmAppPolicy;
    /** Set a single property value on a container directly (outside a function). Allowed only when the property's writability (function | owner | admin) permits the caller. The value is JSON-encoded and coerced to the property's value type. Requires a valid token. For game-logic changes prefer gameModelInvoke. */
    gameModelSetProperty: GmContainer;
    /** Set or clear the session's current-turn user, for turn-based play (authority enforced by the service). Pass userId null to clear the turn. Requires a valid token. */
    gameModelSetSessionTurn: GmSession;
    /** 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. Idempotent on (app, name). Requires app-admin ('manage_apps'). */
    gameModelUpsertAutomation: GmAutomation;
    /** Create an event trigger that fires an automation in reaction to model activity or a complete app-scoped active-player-count transition. player_count_changed rejects model filters, starts silent-baseline tracking, injects reserved previous/current/delta/revision params, and uses trailing-edge debounce; other event behavior is unchanged. Matched in the API server post-commit. Requires app-admin ('manage_apps'). */
    gameModelUpsertAutomationTrigger: GmAutomationTrigger;
    /** Create or update a container type: the studio-defined schema for a kind of runtime entity (like a class). Idempotent on (app, typeName). Requires app-admin ('manage_apps'). */
    gameModelUpsertContainerType: GmContainerType;
    /** Create or update a studio-defined function: a named, sandboxed behavior 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 (app, name). Requires app-admin ('manage_apps'). Returns the function plus any non-fatal static-analysis warnings. */
    gameModelUpsertFunction: GmFunction;
    /** Create or update a property definition on a container type (a typed field with default value, visibility, and writability). Idempotent on (app, containerTypeName, key). Requires app-admin ('manage_apps'). */
    gameModelUpsertPropertyDef: GmPropertyDef;
    /** Grant (or re-activate) a user's access to an app, optionally on a specific tier. Requires the 'manage_access_tiers' permission on the app (input.appId); super admins bypass. ENTITLEMENT CHANGE: upserts an active app_user_access row and notifies the game API, so the target user immediately gains that tier's runtime permissions in Buddy. Idempotent per (app,user): re-granting updates the tier and sets status back to active. */
    grantAppAccess: AppUserAccess;
    /** Grant one or more runtime permission keys directly to a single user on a grid (writes the `grid_user_direct_grants` input table), then recompute that user's materialized effective ACL on the grid. The target user must already have active app access (otherwise this fails). Requires app-admin ('manage_apps'). Returns the user's full effective permission-key set on the grid. To grant by group/role instead of per-user, use `assignGroupToGrid`. */
    grantGridPermissions: GridUserPermissions;
    /** Org dashboard shortcut: the authenticated caller grants themselves access to an app using its default active tier. Requires that the caller is an active member of the app's owning org OR holds the 'manage_access_tiers' permission on the app. ENTITLEMENT CHANGE: upserts an active grant and notifies the game API. Errors if the app has no active tier, or the caller is neither a member nor a manager. */
    grantMyAppAccess: AppUserAccess;
    /** Install an acquired listing after consenting to its capability summary (echo the version's capabilityHash as consentCapabilityHash — a mismatch fails closed). Server halves register through the same P1 registry as instances in a grid the caller OWNS (requires run_server_code) and run as the grid owner on their quota/wallet — never as the author. Bundled client halves attach to the grid for per-visitor consent (D2); omitting gridId makes a personal client-only install. Fail-closed on entitlement, admission, consent, ownership, and run keys. */
    installPlayerCode: PlayerCodeInstall;
    /** Adds a user to an organization as a member. Requires the 'manage_members' permission on the target org (super admins bypass). */
    inviteOrgMember: OrgMember;
    /** Issue a standing grid claim invite (claim policy INVITE). Callable by designated approvers or studio staff holding manage_compute; the invitee then calls claimGridOwnership to take ownership. */
    issueGridClaimInvite: Scalars['Boolean']['output'];
    /** Join a channel as the caller (subscribe to it). Honors the channel membership policy: open -> active immediately, request -> pending (a manager must approve), invite/admin -> rejected. On becoming active, Buddy is notified with the caller's effective send permission so routing starts. */
    joinChannel: GroupMember;
    /** Join a team as the caller. Honors the team membership policy: open -> active immediately, request -> pending (a manager must approve), invite/admin -> rejected. Banned users are rejected. No special permission required. */
    joinTeam: GroupMember;
    /** Leave a channel (unsubscribe the caller). Notifies Buddy to stop routing messages to the caller. Returns true if a membership was removed. */
    leaveChannel: Scalars['Boolean']['output'];
    /** Leave a team (removes the caller's own membership). Returns true if a membership was removed. */
    leaveTeam: Scalars['Boolean']['output'];
    /** 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;
    /** Ends the current session by deleting the game_token that authenticated this request; other devices stay logged in. An identity session logout also cascades to (revokes) every app token it minted. Returns false if no token was resolved. */
    logout: Scalars['Boolean']['output'];
    /** Ends every active session for the authenticated user: deletes every session token and every app-scoped gameplay token derived from one, so the user is signed out of the platform and of every game they had entered. Takes effect immediately — a deleted token stops authenticating on its next request rather than at its next refresh. 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;
    /** Create a disabled player automation confined to the caller and one currently owned grid. Strict trigger/action validation rejects selectors, supplied identities, and app-wide shapes. */
    playerAutomationCreate: PlayerAutomation;
    /** Delete one caller-owned player automation from the specified currently owned grid. Destructive; recorded run rows remain for audit. */
    playerAutomationDelete: Scalars['Boolean']['output'];
    /** Enable or disable one caller-owned player automation. Enabling requires effective run_server_code and, in strict mode, author admission. Interval/cron triggers compute the first due time; the P1 dispatcher executes scheduled studio-model actions while event delivery and player-compute actions remain typed pending paths. */
    playerAutomationSetEnabled: PlayerAutomation;
    /** Delete a self-authored player module and its source versions. Only the code author may delete it, and they must still own the target grid. Returns false when no matching module exists. */
    playerComputeDelete: Scalars['Boolean']['output'];
    /** Deploy player-authored Rust into a grid the caller currently owns. Requires the target's write permission at both app-tier and grid ACL layers. One call creates/updates the module and publishes an immutable pending version; the shared compiler builds it asynchronously. Authoring is never admission-gated, but only the original author may replace closed source. */
    playerComputeDeploy: PlayerWasmModuleVersion;
    /** Synchronously invoke a server player-module export as the current grid owner. Requires the module to be enabled, compiled, admitted, and covered by run_server_code at app and grid scope. The runtime payload carries callerUserId/gridId; author identity never participates. */
    playerComputeInvoke: PlayerComputeInvokeResult;
    /** Enable or disable a player module. Enabling requires current grid ownership, the target's run permission, a successful compile, and admission when the app uses strict ALLOW_LIST mode. Write permission is not sufficient to run code. */
    playerComputeSetEnabled: PlayerWasmModule;
    /** Set or clear the required CLIENT companion for the current immutable SERVER module version. Both modules must be caller-authored, successfully compiled, and in the same owned grid. Enabling the server exposes the aggregate server+client capability summary to visitors; pass null to clear the requirement. */
    playerComputeSetRequires: Scalars['Boolean']['output'];
    /** Throw or release a player-compute kill switch at player, grid, app, or listing scope (the 03 §7 kill ladder). Throwing a switch stops the covered modules on the next scheduler pass; quota state is retained, and releasing resumes normally. LISTING scope (P4a) disables every install of a marketplace listing fleet-wide — pass the listing UUID in listingRef; pair it with the management-side catalog kill to also stop new acquisitions. Module-level disable is playerComputeSetEnabled. Requires the org 'manage_compute' permission. */
    playerComputeSetSwitch: Scalars['Boolean']['output'];
    /** Create a flexible player-model instance in a currently owned grid. The server forces ownerUserId to the caller; this cannot author studio types or app-wide rows. */
    playerModelCreateContainer: PlayerModelContainer;
    /** Delete one caller-owned player-model container and its properties from the specified currently owned grid. Destructive; foreign or absent IDs return NOT_FOUND. */
    playerModelDeleteContainer: Scalars['Boolean']['output'];
    /** Upsert one arbitrary JSON property on a caller-owned player-model container. Requires current ownership of the specified grid. */
    playerModelSetProperty: PlayerModelContainer;
    /** Publishes an app to the shared game-api environment. Free under the org's app-slot quota (result.free = true); beyond the quota, publish still succeeds and hourly usage is debited from the org wallet. Requires the 'manage_apps' permission on the app's org. Blocked when SHARED_GAME_API_URL is not configured. */
    publishAppToShared: PublishAppResult;
    /** Create a marketplace listing (free mode) for code the caller authors — personally, or org-owned via ownerOrgId (DN-9; requires manage_compute in that org). SIDE EFFECTS: writes the catalog row with an ownership audit entry. Publishing never uploads source; versions snapshot artifact hashes only. */
    publishPlayerCode: PlayerCodeListing;
    /** Publish an immutable version under a listing from the caller's successfully compiled module versions. Snapshots artifact hashes, explicit SERVER-to-required-CLIENT edges, and the derived aggregate capability summary; publishing fails if a required client version is absent from the bundle. Source never leaves the author's rows. */
    publishPlayerCodeVersion: PlayerCodeListingVersion;
    /** Buy a grid listing with real money (P4b). Debits the player wallet management-side (platform/org split), then assigns grid_ownership + the listed player-code keys atomically; a failure to apply ownership refunds the charge. For blueprint listings, targetChunk picks where the fresh grid is stamped. This is the ownership path for marketplace_only-policy apps. */
    purchaseGrid: GridPurchaseResult;
    /** 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;
    /** Request a refund of a paid acquisition (P4b). Allowed only within the refund window and before meaningful use (first install/fetch voids it), capped per buyer; a successful refund credits the wallet, reverses the ledger split, claws back the seller balance, revokes the acquisition, and drains installs. Returns cents refunded. */
    refundPlayerCodeAcquisition: Scalars['Int']['output'];
    /** 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;
    /** Release a one-chunk grid previously created through claimGridChunk. Requires an ordinary app-scoped player token and the caller must still be its current user owner. Refuses foreign grids, studio/marketplace grids, and grids assigned through legacy claimGridOwnership. Atomically removes active install attachments, self-claim ownership, direct/effective ACL rows, and the grid so its chunk can be claimed again. Player modules on the grid are deleted by the grid cascade. */
    releaseClaimedGrid: ReleaseClaimedGridResult;
    /** 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'];
    /** Removes a user from an organization. Requires the 'manage_members' permission on the org (super admins bypass). DESTRUCTIVE: revokes the user's membership and role assignments in that org. Returns false if the user was not a member. */
    removeOrgMember: Scalars['Boolean']['output'];
    /** Removes a saved (vaulted) off-session payment method from the org; returns true on success. If it was the method backing auto-billing, recharges will fail until another is set up. Requires the 'manage_billing' org permission. */
    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'];
    /** Renew a RENT acquisition (or extend a TIME_LIMITED window): a wallet charge on the same acquisition that pushes its expiry out. A drained install resumes on the next scheduler pass without re-consent. Paid modes only (P4b). */
    renewPlayerCodeAcquisition: PlayerCodeAcquisition;
    /** 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'];
    /** Pay out the calling player's payable balance to their Connect account (D6 minimum, 7-day delay, reserves enforced). Returns cents paid. */
    requestSellerPayout: Scalars['Int']['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;
    /** Request to join a request-only team (creates a pending membership a manager can approve via addTeamMember). Behaves identically to joinTeam; named for request-policy UIs. */
    requestToJoinTeam: GroupMember;
    /** Re-sends the email-confirmation link. Always returns true regardless of whether the account exists or is already confirmed (prevents enumeration); the email is only sent for existing unconfirmed accounts. Public. */
    resendConfirmationEmail: Scalars['Boolean']['output'];
    /** Completes a password reset using the reset token and a new password. Returns true on success; throws if the token is invalid or expired. Public (the token authorizes the call). Existing sessions are not revoked. */
    resetPassword: Scalars['Boolean']['output'];
    /** 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;
    /** Withdraw consent for an app and immediately invalidate every app-scoped token the authenticated user holds for it, whichever session minted them — the tokens stop authenticating on their next request, not at their next refresh. Atomic: if the tokens cannot be invalidated, consent is left in place and this returns an error, so a successful response is the only state in which access has actually been withdrawn. Does NOT sign the user out: their identity session and their tokens for other apps are untouched. Returns false when there was nothing to revoke (no active grant and no live tokens), which makes a repeat call safe. Requires a SESSION token. */
    revokeAppAuthorization: Scalars['Boolean']['output'];
    /** Revoke an active player-code admission. Requires 'manage_compute'. SIDE EFFECTS: audit row + replica sync; game-api drains affected server modules and blocks client artifact fetches on the next admission refresh. */
    revokeAppCodeAdmission: AppCodeAdmission;
    /** 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. */
    revokeGroupFromGrid: Array<GridGroupGrant>;
    /** Permanently deactivates an org token so it can no longer authenticate. Requires the 'manage_tokens' permission on the token's org (super admins bypass). DESTRUCTIVE and irreversible; the secret cannot be reactivated. Returns false if the token does not exist. */
    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>;
    /** OPERATOR ONLY. Runs the shared-usage billing tick once. It still bills only the last CLOSED clock hour — it will not charge an open hour. Use this to prove a closed-hour debit without waiting for the ~60s cron. Backdating usage rows is a local-test fixture, not something this mutation does on a live tier. */
    runSharedUsageBillingTick: Scalars['Boolean']['output'];
    /** 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'];
    /** Publish a message to a channel, delivered to every active member of the channel (not chunk-routed) as a ChannelMessageNotification on udpNotifications. Requires a bearer game token and the channel send_messages permission; lacking the permission the server drops the message. Opens a UDP proxy session automatically if none exists. The sender receives no echo. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING — NOT confirmation of delivery; failures arrive ASYNCHRONOUSLY as GenericErrorResponse on udpNotifications, correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
    sendChannelMessage: Scalars['Boolean']['output'];
    /** Send a custom, app-defined client event (identified by eventType, a uint16) for spatial replication to nearby chunks; nearby actors receive it as a ClientEventNotification. 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 — NOT that the world processed it. Failures arrive ASYNCHRONOUSLY as GenericErrorResponse on udpNotifications, correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
    sendClientEvent: Scalars['Boolean']['output'];
    /** Send a direct actor-to-actor message, delivered only to the actor identified by targetUuid (NOT broadcast to nearby actors). The sender must know the destination actor’s current chunk. Requires a bearer game token; opens a UDP proxy session automatically if none exists. The target receives a SingleActorMessageNotification on udpNotifications; the sender receives no echo. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING — NOT confirmation of delivery; failures arrive ASYNCHRONOUSLY as GenericErrorResponse on udpNotifications, correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
    sendSingleActorMessage: Scalars['Boolean']['output'];
    /** Operator only (is_operator). Sends a plain test message to one address and returns the SES message id. SIDE EFFECTS: a real outbound email billed to the shared SES identity, and a `send` row in email_events. Prefer the AWS mailbox simulator (success@ / bounce@ / complaint@simulator.amazonses.com), which exercises the whole path without touching a real inbox or a real reputation. `sent: true` with `simulated: true` means SEND_EMAILS is off and nothing left the building -- read both fields. */
    sendTestEmail: SendTestEmailResult;
    /** 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. 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;
    /** Set an app's player-code censorship mode. Requires 'manage_compute'. SIDE EFFECTS: writes an immutable audit row and replica-syncs the mode to game-api. Switching to ALLOW_LIST is strict: unadmitted code (including self-authored code) drains at the runtime activation gate; deploy/compile remain allowed. */
    setAppCodeAdmissionMode: CodeAdmissionMode;
    /** Set an app's compute allowance in units per minute, spanning the model expression engine and both WASM tiers. One unit is one millisecond of measured execution time. An over-ceiling value is REFUSED naming the ceiling (6000000 units per minute) rather than accepted and clamped, so the value reported back is always the value in force. Set enforce to true to refuse invokes when the allowance is exceeded; leave it false to record the decision and admit, which is what produces the measurements a threshold should be chosen from. Requires app-admin ('manage_apps'). */
    setAppComputeBudget: AppComputeBudgetInfo;
    /** Set how a player claim confers grid ownership in this app (D4): SELF_CLAIM, APPROVAL (optionally with a designated approver list), INVITE, or MARKETPLACE_ONLY. Requires 'manage_apps'. SIDE EFFECTS: replica-syncs to game-api, where claimGridOwnership enforces the policy. Changing policy never revokes existing grid_ownership rows. */
    setAppGridClaimPolicy: GridClaimPolicy;
    /** Set the app's marketplace org revenue share in basis points (OQ-3; taken from the post-platform remainder). Requires 'manage_billing'. BWF uses 0. */
    setAppMarketplaceOrgShare: Scalars['Int']['output'];
    /** 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. */
    setAppVisibility: App;
    /** Enables or disables off-session auto-billing for an org and updates its thresholds. When enabled and the wallet falls to lowWaterThresholdCents, the saved payment method is charged rechargeAmountCents (requires setupSharedPaymentMethod first). Pass limitCents=null for no per-period cap. Requires the 'manage_billing' org permission. */
    setAutoBilling: OrgAutoBilling;
    /** OPERATOR ONLY. Sets a metered dimension's price, the UNIT that price is quoted in, its free allowances, or any combination, and returns the new row alongside the values that moved. THIS IS THE ONLY SANCTIONED WAY TO CHANGE A PRICE OR A UNIT: the schema seeds use ON CONFLICT DO NOTHING, so a rate reaches a tier once at install and a unit corrected in the declaration never reaches a tier that already exists. Refuses an unknown or unmetered metric (a rate for a dimension nothing meters bills nobody while appearing configured), refuses a negative price, refuses unitLabel without unitQuantity (which would restate the rate card while the arithmetic kept the old divisor), and refuses a call that would change nothing. A unit change that also moves the money needs acknowledgeRepricing: true, so restating a price and cutting it cannot be confused. NOT RETROACTIVE: charges already written are history and the tick is idempotent per closed hour, so a new rate applies to hours billed from now on. Takes effect within about a minute — both billing ticks reload the card on every run, so no restart is needed. */
    setBillingRate: SetRateCardResult;
    /** Replace a member's channel roles with the given set (not additive — roles not listed are removed). Requires the 'manage_roles' channel permission (app admins bypass). Re-pushes the member's effective send permission to Buddy so their ability to post updates immediately. */
    setChannelMemberRoles: GroupMember;
    /** Set who may create channels in an app and the default membership policy for new channels. Requires app-admin ('manage_apps'). Affects future channel creation only, not existing channels. */
    setChannelPolicy: AppGroupPolicy;
    /** Create or patch an app's Agentic Crowdy Studio policy. Requires 'manage_compute'. Omitted values stay unchanged; first creation starts disabled, killed, and deny-all. A model/tool/mode/risk list naming anything outside the platform allowlist is REFUSED with AGENT_POLICY_INVALID quoting the platform's current list, rather than silently reduced; a list you do send is stored exactly as sent and can only narrow, and omitting it entirely means 'no narrowing', which inherits the platform's list live on every read. Numeric and retention values are still clamped down to platform limits. Locked ZDR/collection/body-retention rules and the operator app kill cannot be changed. SIDE EFFECTS: increments Management's publication revision and appends a sanitized audit event. NOTHING IS PUSHED TO GAME API: its runtime pulls crowdy.studio-agent-policy/1, obtaining a replica the first time a permitted caller asks about an app that has none, and re-pulling an existing replica once it passes refreshAfter (two thirds of its 60s validity). A change therefore reaches enforcement within about a minute for an app already in use, and not at all until someone asks for one that is not. Stable errors: AGENT_POLICY_INVALID, AGENT_POLICY_REVISION_CONFLICT, IDEMPOTENCY_CONFLICT. */
    setCrowdyStudioAgentPolicy: CrowdyStudioAgentPolicy;
    /** Sets the per-user early-access override flag, forcing early access on or off regardless of the global free-play window. Requires a super-admin bearer game token (and the management API enabled). */
    setEarlyAccessOverride: User;
    /** Replace the whitelist of permission keys allowed on a grid (writes the `grid_permission_limits` input table), then recompute the grid's materialized effective ACL so any keys no longer on the whitelist are dropped for all users. Pass an empty array to remove all limits. Requires app-admin ('manage_apps'). DESTRUCTIVE: narrowing the whitelist can strip effective permissions from existing users on the grid. */
    setGridPermissionLimits: GridPermissionLimits;
    /** Adds a password to the signed-in account when it does not have one yet — for an account created by magic link or a social provider, which previously had no in-product way to add password sign-in. Requires a valid session token; the session is the proof of account control, so the password is usable immediately and no email confirmation is needed. Throws CONFLICT if a password is already set (use changePassword, which verifies the current one). A security notification is emailed to the account address. Existing sessions are not revoked. */
    setInitialPassword: Scalars['Boolean']['output'];
    /** Set (author-only) the acquisition mode and pricing for a code listing. Non-free modes require completed seller onboarding. Curation can reject a listing but never reprice it (07 §1.2). */
    setListingPricing: Scalars['Boolean']['output'];
    /** Super-admin only. Flip users.is_operator to grant or revoke control-plane / operator access. */
    setOperator: User;
    /** OPERATOR ONLY. Sets or clears an organization billing exemption. When true, org-wallet debits and money-driven runtime denials are skipped; usage is still metered and every waived amount is written to org_billing_waivers. Does not waive player-wallet charges, failure breakers, or the per-minute compute budget. reason is required when setting true. SIDE EFFECT: re-evaluates the runtime gate for every shared app in the org, so clearing the exemption re-denies immediately instead of waiting for the next hourly tick. */
    setOrgBillingExempt: BillingExemptOrgType;
    /** Super admin only. Used to freeze/unfreeze orgs platform-wide. SIDE EFFECT: sets organizations.status, which gates the org's platform access. */
    setOrgStatus: Organization;
    /** Configure the caller's player-wallet auto-recharge: enable/disable, per-period ceiling, recharge amount, and low-water threshold. Enabling requires a vaulted payment method. */
    setPlayerAutoBilling: PlayerAutoBilling;
    /** Change a listing's catalog status. DELISTED/ACTIVE are owner actions (existing installs keep their pinned versions; delisting only stops new acquisitions). KILLED requires 'manage_compute' on the app (studio/operator) and is the catalog half of the listing kill — pair it with the game-api listing-scope kill switch (playerComputeSetSwitch) to disable running installs fleet-wide. SIDE EFFECTS: audit row + replica sync. */
    setPlayerCodeListingStatus: PlayerCodeListing;
    /** Set the app's player rate-card markup (0..10000 basis points on the platform base price). Markup income accrues per charge to the org's income line and is paid out via the P4b payout ledger. Requires 'manage_billing'. */
    setPlayerRateMarkup: Scalars['Int']['output'];
    /** Set (or clear, by passing both limits null) one of the caller's self-set spend caps: a global or per-app daily/monthly ceiling in cents. Hitting a cap pauses that player's mods with PLAYER_SPEND_CAP until the window rolls — play is untouched. Changes replica-sync to the game runtime. */
    setPlayerSpendCap: Array<PlayerSpendCap>;
    /** Create or update a player-compute policy row at app_default, tier, grid, or user scope. Omitted knobs keep their current value; unitsPerHour/unitsPerDay set the PLAYER_QUOTA_EXHAUSTED budgets (null = uncapped). Every knob is additionally clamped by the app's studio compute policy at runtime, so a player policy can only tighten. Requires 'manage_compute'. */
    setPlayerWasmPolicy: PlayerWasmPolicy;
    /** Creates or updates a quota enforcement rule (idempotent upsert keyed by org/app/tier + metric + period) and returns it. Scope is inferred from the input ids: an app-scoped rule requires the 'manage_quotas' app permission, an org-scoped rule requires the 'manage_quotas' org permission, and a global rule (no org/app/tier) requires super admin. Changes which limit `effectiveQuota` resolves for the metric; does not retroactively alter past usage. */
    setQuota: ServiceQuota;
    /** ADMIN PRIVILEGE CHANGE: grants or revokes platform super-admin on the target user, changing their privileges across the whole platform. Requires a super-admin bearer game token (and the management API enabled). */
    setSuperAdmin: User;
    /** Replace a member's roles with the given set (not additive — roles not listed are removed). Requires the 'manage_roles' team permission (app admins bypass). */
    setTeamMemberRoles: GroupMember;
    /** Set who may create teams in an app and the default membership policy for new teams. Requires app-admin ('manage_apps'). Affects future team creation only, not existing teams. */
    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;
    /** Earn-to-mod: convert payable seller balance into the player wallet without a provider round-trip (07 §4.1). Returns cents credited. */
    spendPayoutBalanceToWallet: Scalars['Int']['output'];
    /** 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;
    /** Top up a COST_LIMITED acquisition's compute-unit budget: a wallet charge that adds the listing's unit budget to the license. Exhausted installs resume once the budget clears their consumed units. Paid modes only (P4b). */
    topUpPlayerCodeAcquisition: PlayerCodeAcquisition;
    /** Transfer grid title to another user. The current user owner or an app admin may transfer. DESTRUCTIVE/SECURITY-SENSITIVE: atomically disables every player module on the grid pending new-owner consent, wipes module state, removes the old owner direct grid grants, and closes the old title row. The new owner receives no implicit permissions. */
    transferGridOwnership: GridOwnership;
    /** Transfer a listing between personal and org ownership (DN-9). The caller must be the current owner (user-owned) or hold manage_compute in the owning org; transfers to an org require manage_compute in the receiving org. SIDE EFFECTS: append-only ownership audit row + replica sync to game-api. Ownership moves listing control and source-access rights; from P4b it also moves proceeds. */
    transferPlayerCodeListing: PlayerCodeListing;
    /** Trust one author’s active client attachments in a grid at the exact aggregate capability hash returned by gridClientMods. The caller must be currently present in the grid. Widening the author’s aggregate capabilities changes the hash and requires a new explicit trust action; attachment-level consent rows are written for compatibility. */
    trustGridAuthor: Scalars['Boolean']['output'];
    /** Uninstall: removes the registered instances, grid client attachments, and fetch rights. The acquisition row is RETAINED for audit; reinstalling later needs no new acquisition. Returns false when no matching active install exists. */
    uninstallPlayerCode: Scalars['Boolean']['output'];
    /** 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. */
    updateActor: Actor;
    /** Replaces an actor’s `publicState` and/or `privateState` blobs (fields omitted from `input` are left unchanged). OWNER-EXCLUSIVE: only the actor’s owner may write (throws Unauthorized otherwise). Requires a valid game token. `uuid` is the 32-character ASCII actor id; blobs are base64-encoded binary. */
    updateActorState: Actor;
    /** Update mutable fields of an existing app (name, description, visibility, status, metadata); only fields present in the input are changed. Requires the 'manage_apps' permission on the app (resolved via its org); super admins bypass. Use this to publish (status=LIVE), change visibility, or restore an archived app (status back to DRAFT/LIVE). Throws if the app id does not exist. */
    updateApp: App;
    /** Updates an avatar’s mutable fields (currently `name`) and returns it. OWNER-EXCLUSIVE: only the avatar’s owner may call this (throws Unauthorized otherwise). Requires a valid game token. To change state blobs use `updateAvatarState`. */
    updateAvatar: Avatar;
    /** Creates or replaces one avatar’s per-app state (upsert keyed by appId+avatarId; bumps updatedAt). OWNER-EXCLUSIVE: only the avatar’s owner may write (throws Unauthorized otherwise); every authenticated user can read it via `avatarAppState`/`avatarAppStates`. Requires a valid game token. `input.state` is base64-encoded binary (null clears it). */
    updateAvatarAppState: AppAvatarState;
    /** Replaces an avatar’s `publicState` and/or `privateState` blobs (fields omitted from `input` are left unchanged). OWNER-EXCLUSIVE: only the owner may write (throws Unauthorized otherwise). Requires a valid game token. Both blobs are base64-encoded binary. */
    updateAvatarState: Avatar;
    /** Update a channel's name, description, and/or membership policy. Requires the 'manage_group' channel permission (app admins bypass). */
    updateChannel: Group;
    /** Update a channel role's name, rank, and/or permission keys (system roles cannot be renamed/re-ranked). When permissions are supplied they REPLACE the role's existing keys. Requires the 'manage_roles' channel permission (app admins bypass). Note: changing send_messages here does not re-push Buddy until affected members' roles are re-applied via setChannelMemberRoles. */
    updateChannelRole: GroupRole;
    /** Creates or replaces a chunk's dense voxel grid and/or per-voxel states for the given app and coordinates, records each provided voxel state as an individual voxel update, and asynchronously uploads the chunk to the CDN. WRITES world state. Leaves chunkState and LODs untouched. Requires a valid bearer token (app-scoped tokens are limited to their own app); no additional org/app permission is enforced on this field. */
    updateChunk: Chunk;
    /** Replaces the level-of-detail (LOD) set for a chunk, preserving voxels, per-voxel states, chunk state and owner; returns the updated chunk (or null if it could not be written). WRITES world state. Requires a valid bearer token AND the `manage_apps` permission on the org that owns input.appId (super admins bypass). */
    updateChunkLods: Maybe<Chunk>;
    /** Upserts ONLY the opaque base64 chunk-level state blob for a chunk, preserving its voxels, per-voxel states and LODs; returns the updated chunk (or null if it could not be written). WRITES world state. Requires a valid bearer token AND the `manage_apps` permission on the org that owns input.appId (super admins bypass). */
    updateChunkState: Maybe<Chunk>;
    /** Sets the authenticated user’s gamertag and disambiguation and appends a gamertag-history row. Requires a valid game token; only ever updates the caller. Fails if the gamertag+disambiguation pair is already taken. */
    updateGamertag: User;
    /** Replaces the full set of roles assigned to an org member. Requires the 'manage_members' permission on the org (super admins bypass). Pass the complete desired role list; roles not included are removed. */
    updateOrgMemberRoles: OrgMember;
    /** Updates a role's name, description, and/or permission set. Requires the 'manage_members' permission on the role's org (super admins bypass). If input.permissions is provided it replaces the entire set (empty array clears all); omit to leave permissions unchanged. */
    updateOrgRole: OrgRole;
    /** Updates an org token's metadata (label, expiry, active flag). Requires the 'manage_tokens' permission on the token's org (super admins bypass). Does not rotate the secret value. */
    updateOrgToken: OrgToken;
    /** Update a team's name, description, and/or membership policy. Requires the 'manage_group' team permission (app admins bypass). */
    updateTeam: Group;
    /** Update a team role's name, rank, and/or permission keys (system roles cannot be renamed/re-ranked). When permissions are supplied they REPLACE the role's existing keys. Requires the 'manage_roles' team permission (app admins bypass). */
    updateTeamRole: GroupRole;
    /** Creates or replaces the authenticated user’s per-app state for `input.appId` (upsert keyed by appId+userId). Requires a valid game token; always writes the caller’s own state. `input.state` is base64-encoded binary. */
    updateUserAppState: UserAppState;
    /** Replaces the authenticated user’s top-level `state` blob (base64-encoded binary; omit/null clears it). Requires a valid game token; only ever writes the caller. */
    updateUserState: User;
    /** Sets the target user’s account `user_type` (e.g. "direct", "deleted"). Requires a super-admin bearer game token (and the management API enabled). */
    updateUserType: User;
    /** Records (upserts) a single voxel edit in the voxel_updates log for one chunk and returns the resulting Voxel. WRITES world state; a background maintenance job later folds these edits into the chunk's packed grid. Requires a valid bearer token AND voxel-edit permission for the target region: the user must have active app access, the `update_voxel_data` tier permission, and (when grids cover the chunk) `update_voxel_data` on a covering grid. */
    updateVoxel: Voxel;
};
export type MutationAcquirePlayerCodeArgs = {
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
};
export type MutationActorHeartbeatArgs = {
    appId: Scalars['BigInt']['input'];
};
export type MutationAddChannelMemberArgs = {
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
};
export type MutationAddTeamMemberArgs = {
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
};
export type MutationAdmitAppCodeArgs = {
    input: AdmitAppCodeInput;
};
export type MutationArchiveAccessTierArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    tierId: Scalars['BigInt']['input'];
};
export type MutationArchiveAppArgs = {
    appId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
};
export type MutationAssignGridOwnershipArgs = {
    input: AssignGridOwnershipInput;
};
export type MutationAssignGroupToGridArgs = {
    input: AssignGroupToGridInput;
};
export type MutationAuthorizeAppArgs = {
    input: AuthorizeAppInput;
};
export type MutationBeginOrgSellerOnboardingArgs = {
    country: Scalars['String']['input'];
    orgId: Scalars['BigInt']['input'];
};
export type MutationBeginSellerOnboardingArgs = {
    country: Scalars['String']['input'];
};
export type MutationCancelSharedSubscriptionArgs = {
    appId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
};
export type MutationCapturePaypalCheckoutArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    orderId: Scalars['String']['input'];
};
export type MutationChangePasswordArgs = {
    currentPassword: Scalars['String']['input'];
    newPassword: Scalars['String']['input'];
};
export type MutationClaimFreeAppAccessArgs = {
    appId: Scalars['BigInt']['input'];
};
export type MutationClaimGridChunkArgs = {
    appId: Scalars['BigInt']['input'];
    chunk: ChunkCoordinatesInput;
};
export type MutationClaimGridOwnershipArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type MutationClearAppComputeBudgetArgs = {
    appId: Scalars['BigInt']['input'];
};
export type MutationCompleteLoginLinkArgs = {
    input: CompleteLoginLinkInput;
};
export type MutationComputeDeleteModuleArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type MutationComputeDeleteTriggerArgs = {
    appId: Scalars['BigInt']['input'];
    triggerId: Scalars['String']['input'];
};
export type MutationComputeDeployTemplateArgs = {
    appId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
    templateName: Scalars['String']['input'];
};
export type MutationComputeDeployVersionArgs = {
    input: DeployComputeVersionInput;
};
export type MutationComputeInvokeArgs = {
    appId: Scalars['BigInt']['input'];
    exportName: Scalars['String']['input'];
    moduleName: Scalars['String']['input'];
    paramsJson?: InputMaybe<Scalars['String']['input']>;
};
export type MutationComputeResetBreakerArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    reason: Scalars['String']['input'];
};
export type MutationComputeSetModuleEnabledArgs = {
    appId: Scalars['BigInt']['input'];
    enabled: Scalars['Boolean']['input'];
    name: Scalars['String']['input'];
};
export type MutationComputeSetPolicyArgs = {
    input: SetComputePolicyInput;
};
export type MutationComputeUpsertModuleArgs = {
    input: UpsertComputeModuleInput;
};
export type MutationComputeUpsertTriggerArgs = {
    input: UpsertComputeTriggerInput;
};
export type MutationConfirmEmailArgs = {
    token: Scalars['String']['input'];
};
export type MutationConsentGridClientModArgs = {
    appId: Scalars['BigInt']['input'];
    attachmentId: Scalars['String']['input'];
    consentCapabilityHash: Scalars['String']['input'];
};
export type MutationCpSetComputePlatformCeilingsArgs = {
    input: CpSetComputePlatformCeilingsInput;
};
export type MutationCpSetCrowdyStudioAgentAppKillArgs = {
    input: SetCrowdyStudioAgentOperatorAppKillInput;
};
export type MutationCpSetCrowdyStudioAgentPlatformPolicyArgs = {
    input: SetCrowdyStudioAgentPlatformPolicyInput;
};
export type MutationCreateAccessTierArgs = {
    input: CreateAccessTierInput;
};
export type MutationCreateActorArgs = {
    input: CreateActorInput;
};
export type MutationCreateAppArgs = {
    input: CreateAppInput;
};
export type MutationCreateAvatarArgs = {
    input: CreateAvatarInput;
};
export type MutationCreateChannelArgs = {
    input: CreateChannelInput;
};
export type MutationCreateChannelRoleArgs = {
    input: CreateGroupRoleInput;
};
export type MutationCreateCheckoutArgs = {
    input: CreateCheckoutInput;
};
export type MutationCreateGridArgs = {
    input: CreateGridInput;
};
export type MutationCreateGridListingArgs = {
    input: CreateGridListingInput;
};
export type MutationCreateOrgRoleArgs = {
    input: CreateOrgRoleInput;
};
export type MutationCreateOrgSellerAccountSessionArgs = {
    country: Scalars['String']['input'];
    orgId: Scalars['BigInt']['input'];
};
export type MutationCreateOrgTokenArgs = {
    input: CreateOrgTokenInput;
};
export type MutationCreateOrganizationArgs = {
    input: CreateOrganizationInput;
};
export type MutationCreatePortalAuthorizationCodeArgs = {
    input: CreatePortalAuthorizationCodeInput;
};
export type MutationCreateSellerAccountSessionArgs = {
    country: Scalars['String']['input'];
};
export type MutationCreateTeamArgs = {
    input: CreateTeamInput;
};
export type MutationCreateTeamRoleArgs = {
    input: CreateGroupRoleInput;
};
export type MutationCreditOrgWalletArgs = {
    amountCents: Scalars['BigInt']['input'];
    orgId: Scalars['BigInt']['input'];
    reason: Scalars['String']['input'];
    referenceId?: InputMaybe<Scalars['String']['input']>;
};
export type MutationCrowdyStudioAgentAcknowledgeEventsArgs = {
    input: AcknowledgeAgentEventsInput;
};
export type MutationCrowdyStudioAgentApproveToolArgs = {
    input: DecideAgentToolInput;
};
export type MutationCrowdyStudioAgentAttachClientArgs = {
    input: AttachAgentClientInput;
};
export type MutationCrowdyStudioAgentCancelRunArgs = {
    input: CancelAgentRunInput;
};
export type MutationCrowdyStudioAgentCloseSessionArgs = {
    input: AgentSessionControlInput;
};
export type MutationCrowdyStudioAgentCreateSessionArgs = {
    input: CreateAgentSessionInput;
};
export type MutationCrowdyStudioAgentGrantLeaseArgs = {
    input: GrantAgentLeaseInput;
};
export type MutationCrowdyStudioAgentHeartbeatArgs = {
    input: AgentHeartbeatInput;
};
export type MutationCrowdyStudioAgentPauseArgs = {
    input: AgentSessionControlInput;
};
export type MutationCrowdyStudioAgentRejectToolArgs = {
    input: DecideAgentToolInput;
};
export type MutationCrowdyStudioAgentResumeArgs = {
    input: AgentSessionControlInput;
};
export type MutationCrowdyStudioAgentRevokeLeaseArgs = {
    input: RevokeAgentLeaseInput;
};
export type MutationCrowdyStudioAgentSendMessageArgs = {
    input: SendAgentMessageInput;
};
export type MutationCrowdyStudioAgentSetModeArgs = {
    input: SetAgentModeInput;
};
export type MutationCrowdyStudioAgentToolResultArgs = {
    input: AgentToolResultInput;
};
export type MutationCrowdyStudioCommonPublishArgs = {
    input: PublishCrowdyStudioCommonFileInput;
};
export type MutationCrowdyStudioLibrarySaveArgs = {
    input: SaveCrowdyStudioLibraryFileInput;
};
export type MutationCrowdyStudioLibrarySetArchivedArgs = {
    input: SetCrowdyStudioLibraryFileArchivedInput;
};
export type MutationCrowdyStudioProjectCreateArgs = {
    input: CreateCrowdyStudioProjectInput;
};
export type MutationCrowdyStudioProjectCreateFromModulesArgs = {
    input: CreateCrowdyStudioProjectFromModulesInput;
};
export type MutationCrowdyStudioProjectImportFileArgs = {
    input: ImportCrowdyStudioProjectFileInput;
};
export type MutationCrowdyStudioProjectSaveArgs = {
    input: SaveCrowdyStudioProjectInput;
};
export type MutationCrowdyStudioProjectSaveFilesArgs = {
    input: SaveCrowdyStudioProjectFilesInput;
};
export type MutationCrowdyStudioProjectSaveMetadataArgs = {
    input: SaveCrowdyStudioProjectMetadataInput;
};
export type MutationCrowdyStudioProjectSetArchivedArgs = {
    input: SetCrowdyStudioProjectArchivedInput;
};
export type MutationDecideCommerceRiskFlagArgs = {
    appId: Scalars['BigInt']['input'];
    flagId: Scalars['String']['input'];
    release: Scalars['Boolean']['input'];
};
export type MutationDecideGridClaimArgs = {
    appId: Scalars['BigInt']['input'];
    approve: Scalars['Boolean']['input'];
    requestId: Scalars['String']['input'];
};
export type MutationDeleteActorArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    uuid: Scalars['String']['input'];
};
export type MutationDeleteAvatarArgs = {
    id: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
};
export type MutationDeleteChannelArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type MutationDeleteChannelRoleArgs = {
    groupRoleId: Scalars['BigInt']['input'];
};
export type MutationDeleteGridArgs = {
    input: DeleteGridInput;
};
export type MutationDeleteOrgRoleArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    orgRoleId: Scalars['BigInt']['input'];
};
export type MutationDeletePlayerWasmPolicyArgs = {
    appId: Scalars['BigInt']['input'];
    scope: Scalars['String']['input'];
    scopeRef?: InputMaybe<Scalars['BigInt']['input']>;
};
export type MutationDeleteQuotaArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    quotaId: Scalars['BigInt']['input'];
};
export type MutationDeleteTeamArgs = {
    groupId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
};
export type MutationDeleteTeamRoleArgs = {
    groupRoleId: Scalars['BigInt']['input'];
};
export type MutationDeleteUserAppStateArgs = {
    appId: Scalars['BigInt']['input'];
};
export type MutationExchangePortalCodeArgs = {
    input: ExchangePortalCodeInput;
};
export type MutationForceLogoutUserArgs = {
    userId: Scalars['BigInt']['input'];
};
export type MutationForgetEmailDeliverabilityArgs = {
    email: Scalars['String']['input'];
};
export type MutationGameModelAddEdgeArgs = {
    input: AddEdgeInput;
};
export type MutationGameModelCancelTimerArgs = {
    appId: Scalars['BigInt']['input'];
    dedupeKey?: InputMaybe<Scalars['String']['input']>;
    timerId?: InputMaybe<Scalars['String']['input']>;
};
export type MutationGameModelCreateContainerArgs = {
    input: CreateContainerInput;
};
export type MutationGameModelCreateSessionArgs = {
    input: CreateSessionInput;
};
export type MutationGameModelDefineFeatureArgs = {
    input: DefineAppFeatureInput;
};
export type MutationGameModelDeleteAutomationArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
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 MutationGameModelEnsureContainerArgs = {
    input: EnsureContainerInput;
};
export type MutationGameModelGrantTierFeatureArgs = {
    input: GrantTierFeatureInput;
};
export type MutationGameModelInvokeArgs = {
    input: InvokeFunctionInput;
};
export type MutationGameModelJoinSessionArgs = {
    input: JoinSessionInput;
};
export type MutationGameModelRevokeTierFeatureArgs = {
    input: GrantTierFeatureInput;
};
export type MutationGameModelRunAutomationArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type MutationGameModelScheduleInvokeArgs = {
    input: ScheduleInvokeInput;
};
export type MutationGameModelSeedArgs = {
    input: SeedGameModelInput;
};
export type MutationGameModelSetAutomationEnabledArgs = {
    appId: Scalars['BigInt']['input'];
    enabled: Scalars['Boolean']['input'];
    name: Scalars['String']['input'];
};
export type MutationGameModelSetAutomationPolicyArgs = {
    input: SetAutomationPolicyInput;
};
export type MutationGameModelSetPolicyArgs = {
    input: SetGameModelPolicyInput;
};
export type MutationGameModelSetPropertyArgs = {
    input: SetContainerPropertyInput;
};
export type MutationGameModelSetSessionTurnArgs = {
    input: SetSessionTurnInput;
};
export type MutationGameModelUpsertAutomationArgs = {
    input: UpsertAutomationInput;
};
export type MutationGameModelUpsertAutomationTriggerArgs = {
    input: UpsertAutomationTriggerInput;
};
export type MutationGameModelUpsertContainerTypeArgs = {
    input: UpsertContainerTypeInput;
};
export type MutationGameModelUpsertFunctionArgs = {
    input: UpsertFunctionInput;
};
export type MutationGameModelUpsertPropertyDefArgs = {
    input: UpsertPropertyDefInput;
};
export type MutationGrantAppAccessArgs = {
    input: GrantAppAccessInput;
};
export type MutationGrantGridPermissionsArgs = {
    input: GrantGridPermissionsInput;
};
export type MutationGrantMyAppAccessArgs = {
    appId: Scalars['BigInt']['input'];
};
export type MutationInstallPlayerCodeArgs = {
    acquisitionId: Scalars['String']['input'];
    appId: Scalars['BigInt']['input'];
    consentCapabilityHash: Scalars['String']['input'];
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    versionId?: InputMaybe<Scalars['String']['input']>;
};
export type MutationInviteOrgMemberArgs = {
    input: InviteOrgMemberInput;
};
export type MutationIssueGridClaimInviteArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    inviteeUserId: Scalars['BigInt']['input'];
};
export type MutationJoinChannelArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type MutationJoinTeamArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type MutationLeaveChannelArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type MutationLeaveTeamArgs = {
    groupId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
};
export type MutationLinkIdentityArgs = {
    input: LinkIdentityInput;
};
export type MutationLoginArgs = {
    loginUserInput: LoginUserInput;
};
export type MutationMintAppTokenArgs = {
    input: MintAppTokenInput;
};
export type MutationPlayerAutomationCreateArgs = {
    input: CreatePlayerAutomationInput;
};
export type MutationPlayerAutomationDeleteArgs = {
    input: PlayerAutomationRefInput;
};
export type MutationPlayerAutomationSetEnabledArgs = {
    input: SetPlayerAutomationEnabledInput;
};
export type MutationPlayerComputeDeleteArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type MutationPlayerComputeDeployArgs = {
    input: DeployPlayerComputeInput;
};
export type MutationPlayerComputeInvokeArgs = {
    appId: Scalars['BigInt']['input'];
    exportName: Scalars['String']['input'];
    gridId: Scalars['BigInt']['input'];
    moduleName: Scalars['String']['input'];
    paramsJson?: InputMaybe<Scalars['String']['input']>;
};
export type MutationPlayerComputeSetEnabledArgs = {
    appId: Scalars['BigInt']['input'];
    enabled: Scalars['Boolean']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type MutationPlayerComputeSetRequiresArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    requiredClientName?: InputMaybe<Scalars['String']['input']>;
    serverName: Scalars['String']['input'];
};
export type MutationPlayerComputeSetSwitchArgs = {
    appId: Scalars['BigInt']['input'];
    disabled: Scalars['Boolean']['input'];
    listingRef?: InputMaybe<Scalars['String']['input']>;
    reason?: InputMaybe<Scalars['String']['input']>;
    scope: Scalars['String']['input'];
    scopeRef?: InputMaybe<Scalars['BigInt']['input']>;
};
export type MutationPlayerModelCreateContainerArgs = {
    input: CreatePlayerModelContainerInput;
};
export type MutationPlayerModelDeleteContainerArgs = {
    input: PlayerModelContainerRefInput;
};
export type MutationPlayerModelSetPropertyArgs = {
    input: SetPlayerModelPropertyInput;
};
export type MutationPublishAppToSharedArgs = {
    appId: Scalars['BigInt']['input'];
    cancelUrl?: InputMaybe<Scalars['String']['input']>;
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    planId?: InputMaybe<Scalars['BigInt']['input']>;
    provider?: InputMaybe<PaymentProvider>;
    successUrl?: InputMaybe<Scalars['String']['input']>;
};
export type MutationPublishPlayerCodeArgs = {
    input: PublishPlayerCodeInput;
};
export type MutationPublishPlayerCodeVersionArgs = {
    input: PublishPlayerCodeVersionInput;
};
export type MutationPurchaseGridArgs = {
    appId: Scalars['BigInt']['input'];
    chunkX?: InputMaybe<Scalars['Int']['input']>;
    chunkY?: InputMaybe<Scalars['Int']['input']>;
    chunkZ?: InputMaybe<Scalars['Int']['input']>;
    gridListingId: Scalars['String']['input'];
};
export type MutationRefundPlayerCodeAcquisitionArgs = {
    acquisitionId: Scalars['String']['input'];
    appId: Scalars['BigInt']['input'];
};
export type MutationRegisterArgs = {
    registerUserInput: RegisterUserInput;
};
export type MutationReleaseClaimedGridArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type MutationRemoveChannelMemberArgs = {
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
};
export type MutationRemoveOrgMemberArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    orgId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
};
export type MutationRemoveSharedPaymentMethodArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    orgId: Scalars['BigInt']['input'];
    paymentMethodId: Scalars['BigInt']['input'];
};
export type MutationRemoveTeamMemberArgs = {
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
};
export type MutationRenewPlayerCodeAcquisitionArgs = {
    acquisitionId: Scalars['String']['input'];
    appId: Scalars['BigInt']['input'];
};
export type MutationRequestLoginLinkArgs = {
    input: RequestLoginLinkInput;
};
export type MutationRequestPasswordResetArgs = {
    email: Scalars['String']['input'];
};
export type MutationRequestToJoinChannelArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type MutationRequestToJoinTeamArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type MutationResendConfirmationEmailArgs = {
    email: Scalars['String']['input'];
};
export type MutationResetPasswordArgs = {
    resetPasswordInput: ResetPasswordInput;
};
export type MutationRevokeAppAccessArgs = {
    appId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    userId: Scalars['BigInt']['input'];
};
export type MutationRevokeAppAuthorizationArgs = {
    appId: Scalars['BigInt']['input'];
};
export type MutationRevokeAppCodeAdmissionArgs = {
    admissionId: Scalars['String']['input'];
    appId: Scalars['BigInt']['input'];
};
export type MutationRevokeGridPermissionsArgs = {
    input: RevokeGridPermissionsInput;
};
export type MutationRevokeGroupFromGridArgs = {
    input: RevokeGroupFromGridInput;
};
export type MutationRevokeOrgTokenArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    orgTokenId: Scalars['BigInt']['input'];
};
export type MutationRollbackVoxelUpdatesArgs = {
    input: RollbackVoxelUpdatesInput;
};
export type MutationSendActorUpdateArgs = {
    input: ActorUpdateRequestInput;
};
export type MutationSendAudioPacketArgs = {
    input: ClientAudioPacketInput;
};
export type MutationSendChannelMessageArgs = {
    input: ChannelMessageInput;
};
export type MutationSendClientEventArgs = {
    input: ClientEventNotificationInput;
};
export type MutationSendSingleActorMessageArgs = {
    input: SingleActorMessageInput;
};
export type MutationSendTestEmailArgs = {
    subject?: InputMaybe<Scalars['String']['input']>;
    to: Scalars['String']['input'];
};
export type MutationSendTextPacketArgs = {
    input: ClientTextPacketInput;
};
export type MutationSendVoxelUpdateArgs = {
    input: VoxelUpdateRequestInput;
};
export type MutationSetAppBudgetArgs = {
    appId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    monthlyLimitCents: Scalars['BigInt']['input'];
    orgId: Scalars['BigInt']['input'];
};
export type MutationSetAppClientSettingsArgs = {
    input: SetAppClientSettingsInput;
};
export type MutationSetAppCodeAdmissionModeArgs = {
    appId: Scalars['BigInt']['input'];
    mode: CodeAdmissionMode;
};
export type MutationSetAppComputeBudgetArgs = {
    appId: Scalars['BigInt']['input'];
    enforce?: InputMaybe<Scalars['Boolean']['input']>;
    note?: InputMaybe<Scalars['String']['input']>;
    unitsPerMinute: Scalars['Int']['input'];
};
export type MutationSetAppGridClaimPolicyArgs = {
    appId: Scalars['BigInt']['input'];
    approverUserIds?: InputMaybe<Array<Scalars['BigInt']['input']>>;
    policy: GridClaimPolicy;
};
export type MutationSetAppMarketplaceOrgShareArgs = {
    appId: Scalars['BigInt']['input'];
    bps: Scalars['Int']['input'];
};
export type MutationSetAppReservedThroughputArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    input: SetAppReservedThroughputInput;
};
export type MutationSetAppSpendCapsArgs = {
    appId: Scalars['BigInt']['input'];
    dailyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
    hourlyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
};
export type MutationSetAppVisibilityArgs = {
    appId: Scalars['BigInt']['input'];
    visibility: AppVisibility;
};
export type MutationSetAutoBillingArgs = {
    enabled: Scalars['Boolean']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    limitCents?: InputMaybe<Scalars['BigInt']['input']>;
    lowWaterThresholdCents?: InputMaybe<Scalars['BigInt']['input']>;
    orgId: Scalars['BigInt']['input'];
    rechargeAmountCents?: InputMaybe<Scalars['BigInt']['input']>;
};
export type MutationSetBillingRateArgs = {
    input: SetRateCardInput;
};
export type MutationSetChannelMemberRolesArgs = {
    input: SetMemberRolesInput;
};
export type MutationSetChannelPolicyArgs = {
    input: SetChannelPolicyInput;
};
export type MutationSetCrowdyStudioAgentPolicyArgs = {
    input: SetCrowdyStudioAgentAppPolicyInput;
};
export type MutationSetEarlyAccessOverrideArgs = {
    userId: Scalars['BigInt']['input'];
    value: Scalars['Boolean']['input'];
};
export type MutationSetGridPermissionLimitsArgs = {
    input: SetGridPermissionLimitsInput;
};
export type MutationSetInitialPasswordArgs = {
    newPassword: Scalars['String']['input'];
};
export type MutationSetListingPricingArgs = {
    input: SetListingPricingInput;
};
export type MutationSetOperatorArgs = {
    userId: Scalars['BigInt']['input'];
    value: Scalars['Boolean']['input'];
};
export type MutationSetOrgBillingExemptArgs = {
    exempt: Scalars['Boolean']['input'];
    orgId: Scalars['BigInt']['input'];
    reason: Scalars['String']['input'];
};
export type MutationSetOrgStatusArgs = {
    orgId: Scalars['BigInt']['input'];
    status: Scalars['String']['input'];
};
export type MutationSetPlayerAutoBillingArgs = {
    enabled: Scalars['Boolean']['input'];
    limitCents?: InputMaybe<Scalars['BigInt']['input']>;
    lowWaterThresholdCents?: InputMaybe<Scalars['BigInt']['input']>;
    rechargeAmountCents?: InputMaybe<Scalars['BigInt']['input']>;
};
export type MutationSetPlayerCodeListingStatusArgs = {
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
    status: PlayerCodeListingStatus;
};
export type MutationSetPlayerRateMarkupArgs = {
    appId: Scalars['BigInt']['input'];
    markupBps: Scalars['Int']['input'];
};
export type MutationSetPlayerSpendCapArgs = {
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    dailyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
    monthlyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
    scope: Scalars['String']['input'];
};
export type MutationSetPlayerWasmPolicyArgs = {
    input: SetPlayerWasmPolicyInput;
};
export type MutationSetQuotaArgs = {
    input: SetQuotaInput;
};
export type MutationSetSuperAdminArgs = {
    userId: Scalars['BigInt']['input'];
    value: Scalars['Boolean']['input'];
};
export type MutationSetTeamMemberRolesArgs = {
    input: SetMemberRolesInput;
};
export type MutationSetTeamPolicyArgs = {
    input: SetTeamPolicyInput;
};
export type MutationSetupSharedPaymentMethodArgs = {
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    orgId: Scalars['BigInt']['input'];
};
export type MutationSocialLoginCompleteArgs = {
    input: SocialLoginCompleteInput;
};
export type MutationSocialLoginStartArgs = {
    input: SocialLoginStartInput;
};
export type MutationSpendPayoutBalanceToWalletArgs = {
    amountCents: Scalars['Int']['input'];
};
export type MutationTeleportRequestArgs = {
    input: TeleportRequestInput;
};
export type MutationTopUpPlayerCodeAcquisitionArgs = {
    acquisitionId: Scalars['String']['input'];
    appId: Scalars['BigInt']['input'];
};
export type MutationTransferGridOwnershipArgs = {
    input: TransferGridOwnershipInput;
};
export type MutationTransferPlayerCodeListingArgs = {
    input: TransferPlayerCodeListingInput;
};
export type MutationTrustGridAuthorArgs = {
    appId: Scalars['BigInt']['input'];
    authorKind: PlayerCodeOwnerKind;
    authorRef: Scalars['BigInt']['input'];
    consentCapabilityHash: Scalars['String']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type MutationUninstallPlayerCodeArgs = {
    appId: Scalars['BigInt']['input'];
    installId: Scalars['String']['input'];
};
export type MutationUnlinkIdentityArgs = {
    identityId: Scalars['String']['input'];
};
export type MutationUpdateAccessTierArgs = {
    input: UpdateAccessTierInput;
    tierId: Scalars['BigInt']['input'];
};
export type MutationUpdateActorArgs = {
    input: UpdateActorInput;
    uuid: Scalars['String']['input'];
};
export type MutationUpdateActorStateArgs = {
    input: UpdateActorStateInput;
    uuid: Scalars['String']['input'];
};
export type MutationUpdateAppArgs = {
    appId: Scalars['BigInt']['input'];
    input: UpdateAppInput;
};
export type MutationUpdateAvatarArgs = {
    id: Scalars['BigInt']['input'];
    input: UpdateAvatarInput;
};
export type MutationUpdateAvatarAppStateArgs = {
    input: UpdateAvatarAppStateInput;
};
export type MutationUpdateAvatarStateArgs = {
    id: Scalars['BigInt']['input'];
    input: UpdateAvatarStateInput;
};
export type MutationUpdateChannelArgs = {
    input: UpdateChannelInput;
};
export type MutationUpdateChannelRoleArgs = {
    input: UpdateGroupRoleInput;
};
export type MutationUpdateChunkArgs = {
    input: ChunkUpdateInput;
};
export type MutationUpdateChunkLodsArgs = {
    input: UpdateChunkLodsInput;
};
export type MutationUpdateChunkStateArgs = {
    input: UpdateChunkStateInput;
};
export type MutationUpdateGamertagArgs = {
    input: UpdateGamertagInput;
};
export type MutationUpdateOrgMemberRolesArgs = {
    orgId: Scalars['BigInt']['input'];
    roleIds: Array<Scalars['BigInt']['input']>;
    userId: Scalars['BigInt']['input'];
};
export type MutationUpdateOrgRoleArgs = {
    input: UpdateOrgRoleInput;
    orgRoleId: Scalars['BigInt']['input'];
};
export type MutationUpdateOrgTokenArgs = {
    input: UpdateOrgTokenInput;
    orgTokenId: Scalars['BigInt']['input'];
};
export type MutationUpdateTeamArgs = {
    input: UpdateTeamInput;
};
export type MutationUpdateTeamRoleArgs = {
    input: UpdateGroupRoleInput;
};
export type MutationUpdateUserAppStateArgs = {
    input: CreateUserAppStateInput;
};
export type MutationUpdateUserStateArgs = {
    input: UpdateUserStateInput;
};
export type MutationUpdateUserTypeArgs = {
    userId: Scalars['BigInt']['input'];
    value: Scalars['String']['input'];
};
export type MutationUpdateVoxelArgs = {
    input: UpdateVoxelInput;
};
/** A grid overlapping a scanned region, plus a user's effective permission keys on it (returned by nearbyGridPermissions). */
export type NearbyGridPermissions = {
    __typename?: 'NearbyGridPermissions';
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['output'];
    /** The grid id. */
    gridId: Scalars['BigInt']['output'];
    /** High (maximum) corner chunk of the grid box. */
    highChunk: ChunkCoordinates;
    /** Low (minimum) corner chunk of the grid box. */
    lowChunk: ChunkCoordinates;
    /** The user's effective runtime permission key strings on this grid. */
    permissionKeys: Array<Scalars['String']['output']>;
    /** The user the permissions were computed for. */
    userId: Scalars['BigInt']['output'];
};
/** Scan a region for grids and report a user's effective permissions on each. */
export type NearbyGridPermissionsInput = {
    /** The app (tenant) to scan within. */
    appId: Scalars['BigInt']['input'];
    /** High corner of the region to scan, in chunk coordinates (normalized). */
    highChunk: ChunkCoordinatesInput;
    /** Low corner of the region to scan, in chunk coordinates (normalized). */
    lowChunk: ChunkCoordinatesInput;
    /** The user whose effective permissions to report per grid. */
    userId: Scalars['BigInt']['input'];
};
/** One named argument expression of a notify_* effect. */
export type NotificationArgInput = {
    /** Expression string (compiled to AST server-side; evaluated post-mutation). */
    expression: Scalars['String']['input'];
    /** 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';
    /** Amount already auto-billed in the current period, in cents. */
    autoBilledThisPeriodCents: Scalars['BigInt']['output'];
    /** Whether off-session auto-billing is enabled. */
    enabled: Scalars['Boolean']['output'];
    /** True when a vaulted payment method exists to charge off-session. */
    hasPaymentMethod: Scalars['Boolean']['output'];
    /** Most recent auto-billing failure message, if any. */
    lastError: Maybe<Scalars['String']['output']>;
    /** Max auto-billed per period in cents. Null = no limit. */
    limitCents: Maybe<Scalars['BigInt']['output']>;
    /** Wallet balance at or below which an auto-recharge is triggered, in cents. */
    lowWaterThresholdCents: Scalars['BigInt']['output'];
    /** Organization id (BigInt). */
    orgId: Scalars['BigInt']['output'];
    /** Reset window for the per-period auto-billed total, e.g. 'month'. */
    period: Scalars['String']['output'];
    /** Amount to top up the wallet by on each auto-recharge, in cents. */
    rechargeAmountCents: Scalars['BigInt']['output'];
};
export type OrgMember = {
    __typename?: 'OrgMember';
    /** When the membership was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Organization this membership belongs to (BigInt as string). */
    orgId: Scalars['BigInt']['output'];
    /** Unique membership id (primary key, BigInt as string). Distinct from userId. */
    orgMemberId: Scalars['BigInt']['output'];
    /** Membership status. Only 'active' members count for permission checks; other values (e.g. 'invited' or 'removed') grant no permissions. */
    status: Scalars['String']['output'];
    /** When the membership was last updated. */
    updatedAt: Scalars['DateTime']['output'];
    /** The member's user_id (BigInt as string). */
    userId: Scalars['BigInt']['output'];
};
/** Represents one user's membership in one organization. Bundles the org, the union of permissions across the user's assigned roles, and the role list itself - so the UI can render an org dashboard without a follow-up round trip. */
export type OrgMembership = {
    __typename?: 'OrgMembership';
    /** When the user joined the organization. */
    joinedAt: Scalars['DateTime']['output'];
    /** The organization. */
    org: Organization;
    /** Effective permission keys the user holds in this org (union across assigned roles; full set for super admins). */
    permissions: Array<Scalars['String']['output']>;
    /** Roles assigned to the user in this org. */
    roles: Array<OrgRole>;
};
export type OrgPermission = {
    __typename?: 'OrgPermission';
    /** Optional grouping category for UI display. */
    category: Maybe<Scalars['String']['output']>;
    /** Human-readable explanation of what the permission allows. */
    description: Maybe<Scalars['String']['output']>;
    /** Stable permission key used in role grants (e.g. 'manage_members', 'manage_tokens'). */
    permissionKey: Scalars['ID']['output'];
};
export type OrgRole = {
    __typename?: 'OrgRole';
    /** When the role was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional human-readable description of the role. */
    description: Maybe<Scalars['String']['output']>;
    /** True for built-in / seeded roles managed by the platform; typically not editable. */
    isSystem: Scalars['Boolean']['output'];
    /** Organization this role belongs to (BigInt as string). */
    orgId: Scalars['BigInt']['output'];
    /** Unique role id (primary key, BigInt as string). */
    orgRoleId: Scalars['BigInt']['output'];
    /** Permission keys granted by this role (resolved from org_role_permissions). */
    permissions: Array<Scalars['String']['output']>;
    /** Display name of the role. */
    roleName: Scalars['String']['output'];
};
export type OrgToken = {
    __typename?: 'OrgToken';
    /** When the token was created. */
    createdAt: Scalars['DateTime']['output'];
    /** For 'service' tokens, the environment id (UUID) the token is scoped to; null for user-minted tokens. */
    environmentId: Maybe<Scalars['String']['output']>;
    /** Optional expiry timestamp; null means the token never expires. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** False once revoked; inactive tokens cannot authenticate. */
    isActive: Scalars['Boolean']['output'];
    /** 'user_minted' (human-created) or 'service' (minted by the control plane for per-tenant game-apis). */
    kind: Scalars['String']['output'];
    /** Optional human-readable label. */
    label: Maybe<Scalars['String']['output']>;
    /** When the token last authenticated a request, if ever. */
    lastUsedAt: Maybe<Scalars['DateTime']['output']>;
    /** Organization that owns this token (BigInt as string). */
    orgId: Scalars['BigInt']['output'];
    /** Unique token id (primary key, BigInt as string). */
    orgTokenId: Scalars['BigInt']['output'];
    /** When the token was revoked, if it has been. */
    revokedAt: Maybe<Scalars['DateTime']['output']>;
    /** When the token was last updated. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Returned exactly once - on org token creation. The plaintext `token` field is never re-emitted. Future listings show metadata only via the `OrgToken` type. */
export type OrgTokenWithSecret = {
    __typename?: 'OrgTokenWithSecret';
    /** When the token was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional expiry timestamp; null means no expiry. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** Whether the token is active. */
    isActive: Scalars['Boolean']['output'];
    /** Optional human-readable label. */
    label: Maybe<Scalars['String']['output']>;
    /** Organization that owns this token (BigInt as string). */
    orgId: Scalars['BigInt']['output'];
    /** Unique token id (BigInt as string). */
    orgTokenId: Scalars['BigInt']['output'];
    /** 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. */
    balanceCents: Scalars['BigInt']['output'];
    /** When the wallet was created (ISO-8601 UTC timestamp). */
    createdAt: Scalars['DateTime']['output'];
    /** ISO-4217 currency code for `balanceCents`, lowercase (e.g. "usd"). Defaults to "usd". */
    currency: Scalars['String']['output'];
    /** Organization that owns this wallet (BigInt as a decimal string). There is exactly one wallet per organization. */
    orgId: Scalars['BigInt']['output'];
    /** When the wallet was last modified, e.g. on balance change (ISO-8601 UTC timestamp). */
    updatedAt: Scalars['DateTime']['output'];
    /** Unique wallet id (BigInt as a decimal string). */
    walletId: Scalars['BigInt']['output'];
};
export type Organization = {
    __typename?: 'Organization';
    /** When the organization was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Human-readable organization name. */
    name: Scalars['String']['output'];
    /** Unique organization id (primary key). BigInt as a string. */
    orgId: Scalars['BigInt']['output'];
    /** user_id of the organization owner (BigInt as string). */
    ownerUserId: Scalars['BigInt']['output'];
    /** Unique URL-safe slug (lowercase letters, numbers, and dashes). */
    slug: Scalars['String']['output'];
    /** Lifecycle status, e.g. 'active' or 'frozen'. Set platform-wide via setOrgStatus. */
    status: Scalars['String']['output'];
    /** When the organization was last updated. */
    updatedAt: Scalars['DateTime']['output'];
};
export type PageInfo = {
    __typename?: 'PageInfo';
    limit: Scalars['Int']['output'];
    offset: Scalars['Int']['output'];
    totalCount: Scalars['Int']['output'];
};
/** A single inbound payment-provider webhook event from the reconciliation audit log. */
export type PaymentEventRecord = {
    __typename?: 'PaymentEventRecord';
    /** Checkout this event was matched to (BigInt as a decimal string); null if it could not be matched. */
    checkoutId: Maybe<Scalars['BigInt']['output']>;
    /** When the event was received (ISO-8601 UTC timestamp). */
    createdAt: Scalars['DateTime']['output'];
    /** Error message if processing this event failed; null on success. */
    error: Maybe<Scalars['String']['output']>;
    /** Unique payment-event id (BigInt as a decimal string). */
    eventId: Scalars['BigInt']['output'];
    /** Provider event type string (e.g. "checkout.session.completed" for Stripe). */
    eventType: Scalars['String']['output'];
    /** Provider-assigned event id, unique per provider; used to make webhook handling idempotent. */
    externalEventId: Scalars['String']['output'];
    /** When the event was successfully processed (ISO-8601 UTC timestamp); null if not yet processed. */
    processedAt: Maybe<Scalars['DateTime']['output']>;
    /** Provider that delivered this webhook event. */
    provider: PaymentProvider;
};
/** An edge in a PaymentEventRecord connection. */
export type PaymentEventRecordEdge = {
    __typename?: 'PaymentEventRecordEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: PaymentEventRecord;
};
/** A Relay cursor connection over PaymentEventRecord rows. Page with first/after; pass pageInfo.endCursor back as after for the next page. */
export type PaymentEventsConnection = {
    __typename?: 'PaymentEventsConnection';
    /** Edges on this page. */
    edges: Array<PaymentEventRecordEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** A page of payment webhook events with offset/limit pagination metadata. */
export type PaymentEventsPage = {
    __typename?: 'PaymentEventsPage';
    /** The webhook events on this page, ordered newest first. */
    items: Array<PaymentEventRecord>;
    /** Offset/limit pagination metadata (totalCount, limit, offset) for this result set. */
    pageInfo: PageInfo;
};
/** Stripe SetupIntent handle the browser uses to vault a card for auto-billing. */
export type PaymentMethodSetup = {
    __typename?: 'PaymentMethodSetup';
    /** SetupIntent client secret the browser confirms to vault the card. */
    clientSecret: Maybe<Scalars['String']['output']>;
    /** Provider customer id (e.g. Stripe customer) the card is vaulted under. */
    externalCustomerId: Scalars['String']['output'];
    /** Provider publishable key for the browser SDK. */
    publishableKey: Maybe<Scalars['String']['output']>;
};
/** External payment processor for a checkout. */
export declare enum PaymentProvider {
    /** PayPal. Hosted approval flow; the approved order is captured via capturePaypalCheckout (which completes the checkout), with PayPal webhooks as backup reconciliation. */
    Paypal = "PAYPAL",
    /** Stripe Checkout. Hosted card payment session; completion is confirmed via Stripe webhooks. */
    Stripe = "STRIPE"
}
/** One datacenter an app can be created in. The `code` is exactly what createApp takes as input.datacenter. */
export type PlaceableDatacenter = {
    __typename?: 'PlaceableDatacenter';
    /** How many shards of the app colocation group this datacenter currently holds. This is the placement odds: createApp mints candidate app ids until one hashes into the requested datacenter, so a datacenter holding half the shards is satisfied in about two attempts. Zero means unplaceable. Always 0 on a deployment that distributes nothing, where the number does not exist and `placeable` is true regardless — read `placeable`, not this, to decide whether a choice is offerable. */
    appShardCount: Scalars['Int']['output'];
    /** Datacenter code, e.g. 'or' or 'va'. Pass this verbatim as createApp's input.datacenter; it is compared lowercase. */
    code: Scalars['String']['output'];
    /** HTTPS GraphQL origin clients of an app in this datacenter should use. Null only where no topology has been pushed, which on a Citus deployment means the datacenter cannot yet be reached and on a single-node one means there is nothing to route. Informational for a picker: createApp does not need it, and appDiscovery is what a client reads per app. */
    gameApiUrl: Maybe<Scalars['String']['output']>;
    /** The wss:// form of gameApiUrl. Null under the same conditions. */
    gameApiWsUrl: Maybe<Scalars['String']['output']>;
    /** Whether createApp will accept this datacenter right now. False means it holds no shards of the app colocation group, so no app id can hash into it and creation would fail after exhausting its candidates. Do not offer a false entry as a choice — show it as unavailable, because dropping it hides a half-built datacenter from the only person who would notice. */
    placeable: Scalars['Boolean']['output'];
    /** Whether any ck-api instance in this datacenter is currently serving clients. NOT part of whether an app can be PLACED here: placement is about where the data lands and survives a datacenter being down, while this is about whether players could connect today. A datacenter that is placeable but NOT_SERVING will hold the app fine and answer its clients with APP_UNAVAILABLE until an instance comes back, so it is worth warning about and wrong to forbid. UNKNOWN means the liveness signal itself could not be read and must not be shown as an outage — a fleet-wide heartbeat failure once made every datacenter look dead while all of them were fine. */
    serving: DatacenterServingStatus;
};
/** The datacenter choices this deployment offers for app creation, plus the two facts a caller needs to interpret an empty list. */
export type PlaceableDatacenters = {
    __typename?: 'PlaceableDatacenters';
    /** Every datacenter this deployment knows how to route to, sorted by code, including any that cannot currently hold an app. EMPTY means the control plane has never pushed a datacenter topology here, in which case createApp refuses every datacenter and the remedy is a change order (pg:upsert_datacenter_topology) rather than a different argument. */
    datacenters: Array<PlaceableDatacenter>;
    /** Whether this deployment actually places apps by datacenter. True on any Citus tier: the datacenter is verified at creation and an unknown or empty one is refused. False on a single-node deployment (a developer machine, the CI database), where there is exactly one place an app can be, the argument is still required but cannot be verified, and the single entry returned is a formality. A caller should present a choice when this is true and need not when it is false. */
    placementEnforced: Scalars['Boolean']['output'];
    /** The datacenter of the instance that answered this call, or null if it was not told its own. Present so a picker can SAY which datacenter it is talking to; deliberately NOT a default. The published origin is a multivalue record over every datacenter's load balancer, so the instance answering is whichever one DNS picked, and defaulting to it would place apps by exactly the accident createApp's required argument exists to remove. */
    servedBy: Maybe<Scalars['String']['output']>;
};
/** Public platform discovery. Clients/SDKs read the shared game-api URL here to route apps deployed to the shared environment. */
export type PlatformConfig = {
    __typename?: 'PlatformConfig';
    /** Free shared app slots an org gets before usage is wallet-billed. */
    freeAppsPerOrg: Scalars['Int']['output'];
    /** Shared game-api HTTP/GraphQL root for shared-environment apps. */
    sharedGameApiUrl: Maybe<Scalars['String']['output']>;
    /** Shared game-api WebSocket root (subscriptions / UDP proxy). */
    sharedGameApiWsUrl: Maybe<Scalars['String']['output']>;
};
/** Off-session auto-recharge settings for the player wallet (the org auto-billing twin): when enabled with a vaulted card, the player gate tops the wallet up before denying for insufficient funds. */
export type PlayerAutoBilling = {
    __typename?: 'PlayerAutoBilling';
    /** Amount auto-billed so far this period. */
    autoBilledThisPeriodCents: Scalars['BigInt']['output'];
    /** Whether auto-recharge is enabled. */
    enabled: Scalars['Boolean']['output'];
    /** Whether an active vaulted card is attached. */
    hasPaymentMethod: Scalars['Boolean']['output'];
    /** Last auto-recharge failure, if any. */
    lastError: Maybe<Scalars['String']['output']>;
    /** Per-period auto-recharge ceiling in cents; null = no limit. */
    limitCents: Maybe<Scalars['BigInt']['output']>;
    /** Balance threshold that triggers a recharge. */
    lowWaterThresholdCents: Scalars['BigInt']['output'];
    /** Amount charged per auto-recharge. */
    rechargeAmountCents: Scalars['BigInt']['output'];
    /** The owning player user id. */
    userId: Scalars['BigInt']['output'];
};
/** A player-owned automation confined to one app and grid. Trigger/action JSON has been structurally validated. */
export type PlayerAutomation = {
    __typename?: 'PlayerAutomation';
    /** Validated action as canonical JSON. */
    actionJson: Scalars['String']['output'];
    /** App containing the automation. */
    appId: Scalars['BigInt']['output'];
    /** Player automation UUID. */
    automationId: Scalars['String']['output'];
    /** Circuit state: closed, open, or half_open. */
    circuitState: Scalars['String']['output'];
    /** Current consecutive failure count. */
    consecutiveFailures: Scalars['Int']['output'];
    /** Open-circuit cooldown in milliseconds. */
    cooldownMs: Scalars['Int']['output'];
    /** Automation creation time. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional description. */
    description: Maybe<Scalars['String']['output']>;
    /** Whether the automation may dispatch. */
    enabled: Scalars['Boolean']['output'];
    /** Failures required to open the circuit. */
    failureThreshold: Scalars['Int']['output'];
    /** Grid confining the automation. */
    gridId: Scalars['BigInt']['output'];
    /** Most recent dispatch error. */
    lastError: Maybe<Scalars['String']['output']>;
    /** Most recent dispatch time. */
    lastRunAt: Maybe<Scalars['DateTime']['output']>;
    /** Maximum runs per rolling minute. */
    maxRunsPerMinute: Scalars['Int']['output'];
    /** Owner-local automation name. */
    name: Scalars['String']['output'];
    /** Next scheduled dispatch time. */
    nextRunAt: Maybe<Scalars['DateTime']['output']>;
    /** Owning user. Forced from current grid ownership at creation. */
    ownerUserId: Scalars['BigInt']['output'];
    /** Time at which an open circuit may retry. */
    pausedUntil: Maybe<Scalars['DateTime']['output']>;
    /** Validated trigger as canonical JSON. */
    triggerJson: Scalars['String']['output'];
    /** Most recent automation update time. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Identify one player automation within its app and grid. The server additionally forces the current caller as owner. */
export type PlayerAutomationRefInput = {
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Player automation UUID. */
    automationId: Scalars['String']['input'];
    /** Grid that confines the automation. */
    gridId: Scalars['BigInt']['input'];
};
/** A pending player card-vault (P4b): the Stripe SetupIntent the browser confirms to save a card off-session, enabling wallet auto-recharge and rent auto-renew. On success a setup_intent.succeeded webhook persists the card. */
export type PlayerCardSetup = {
    __typename?: 'PlayerCardSetup';
    /** Stripe SetupIntent client secret the browser confirms. */
    clientSecret: Maybe<Scalars['String']['output']>;
    /** The Stripe customer id the card is attached to. */
    externalCustomerId: Scalars['String']['output'];
    /** Stripe publishable key the browser needs to confirm the card. */
    publishableKey: Maybe<Scalars['String']['output']>;
};
/** A compiled CLIENT-target player artifact plus the metadata the browser broker needs to run it (player compute P3). Served only to the current grid owner who authored the version, holding run_client_code, when the app's admission mode admits the code. The bytes are the gas-injected wasm32-unknown-unknown module; clientFuelPerDispatch is the per-dispatch fuel budget the glue worker enforces locally. */
export type PlayerClientArtifact = {
    __typename?: 'PlayerClientArtifact';
    /** ABI version the artifact was built for. */
    abiVersion: Scalars['Int']['output'];
    /** The gas-injected client WASM artifact, base64-encoded. */
    artifactBase64: Scalars['String']['output'];
    /** SHA-256 content hash of the served artifact bytes. The browser broker recomputes it and refuses any artifact whose hash differs, so a side-loaded module cannot run (T7). */
    artifactHash: Scalars['String']['output'];
    /** Per-dispatch client fuel budget from the resolved player policy; the broker's glue worker traps when a dispatch exceeds it. */
    clientFuelPerDispatch: Scalars['BigInt']['output'];
    /** Declared client interop contract (bridge messages) as JSON, when the version pins one. */
    contractJson: Maybe<Scalars['String']['output']>;
    /** Artifact size in bytes (<= 512 KiB). */
    sizeBytes: Scalars['Int']['output'];
    /** The served version UUID. */
    versionId: Scalars['String']['output'];
};
/** The caller's entitlement to a listing (mode 'free' in P4a). Uninstalling never deletes this row; it is the audit trail P4b attaches payment to. */
export type PlayerCodeAcquisition = {
    __typename?: 'PlayerCodeAcquisition';
    /** When acquired. */
    acquiredAt: Scalars['DateTime']['output'];
    /** Numeric user id of the acquirer (management catalog reads). */
    acquirerUserId: Maybe<Scalars['BigInt']['output']>;
    /** UUID of the acquisition. */
    acquisitionId: Scalars['String']['output'];
    /** App of the listing. */
    appId: Scalars['BigInt']['output'];
    /** Expiry for RENT/TIME_LIMITED; null for perpetual (FREE/BUY) or unit-budgeted (COST_LIMITED). Past expiry drains installs until renewed. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** UUID of the acquired listing. */
    listingId: Scalars['String']['output'];
    /** Acquisition mode: FREE, BUY (perpetual), RENT (renewable window), TIME_LIMITED (single window), or COST_LIMITED (compute-unit budget). */
    mode: PlayerCodeAcquisitionMode;
    /** When the entitlement was revoked; null while active. */
    revokedAt: Maybe<Scalars['DateTime']['output']>;
    /** Entitlement status: 'active' or 'revoked'. */
    status: Scalars['String']['output'];
    /** Compute-unit budget for COST_LIMITED; null otherwise. */
    unitBudget: Maybe<Scalars['BigInt']['output']>;
    /** Compute units consumed so far (advances against unitBudget). */
    unitsConsumed: Scalars['BigInt']['output'];
};
/** How a listing is acquired. P4a ships FREE only; the paid modes (buy, rent, time-limited, cost-limited) arrive with the P4b money workstream. */
export declare enum PlayerCodeAcquisitionMode {
    Buy = "BUY",
    CostLimited = "COST_LIMITED",
    Free = "FREE",
    Rent = "RENT",
    TimeLimited = "TIME_LIMITED"
}
/** One row of an app's admission queue: a listing joined with its standing under the app's allow-list (admitted via a matching code, author, or org admission; pending; or revoked). The studio moderation surface for allow_list apps. */
export type PlayerCodeAdmissionQueueEntry = {
    __typename?: 'PlayerCodeAdmissionQueueEntry';
    /** UUID of the admission entry that admits (or last admitted) this listing — matched on the code subject, its author, or its owning org. Null while pending. */
    admissionId: Maybe<Scalars['String']['output']>;
    /** The listing's admission standing in this app. */
    admissionState: PlayerCodeAdmissionState;
    /** The listing under review. */
    listing: PlayerCodeListing;
    /** Which allow-list subject matched: 'code', 'author', or 'org'. Null while pending. */
    matchedSubjectKind: Maybe<Scalars['String']['output']>;
};
/** A listing's standing under this app's admission mode: ADMITTED (installable), PENDING (browsable but uninstallable in allow_list apps), or REVOKED (installs drain). */
export declare enum PlayerCodeAdmissionState {
    Admitted = "ADMITTED",
    Pending = "PENDING",
    Revoked = "REVOKED"
}
/** An install of an acquired listing: the pinned version, the consent hash acknowledged, and (for server halves) the owned target grid. Installs pin their version; updating to a newer version is a new consent + install update, never automatic. */
export type PlayerCodeInstall = {
    __typename?: 'PlayerCodeInstall';
    /** UUID of the acquisition this install uses. */
    acquisitionId: Scalars['String']['output'];
    /** App of the listing. */
    appId: Scalars['BigInt']['output'];
    /** The capability hash the installer consented to. */
    consentedCapabilityHash: Scalars['String']['output'];
    /** When installed. */
    createdAt: Scalars['DateTime']['output'];
    /** UUID of the install. */
    installId: Scalars['String']['output'];
    /** UUID of the installed listing. */
    listingId: Scalars['String']['output'];
    /** UUID of the pinned listing version. */
    pinnedVersionId: Scalars['String']['output'];
    /** Install status: 'active', 'uninstalled', or 'disabled'. */
    status: Scalars['String']['output'];
    /** Owned grid the server half (and any bundled client attachment) was installed into; null for personal client-only installs. */
    targetGridId: Maybe<Scalars['BigInt']['output']>;
};
/** Source-access mode of a listing: CLOSED (artifacts + contracts only) or OPEN_SOURCE (source readable; irreversible per published version). */
export declare enum PlayerCodeLicenseMode {
    Closed = "CLOSED",
    OpenSource = "OPEN_SOURCE"
}
/** A marketplace code listing as seen in-game (replica of the management catalog). Every listing is FREE in P4a; carrying both server and client artifact sets makes it a bundle. */
export type PlayerCodeListing = {
    __typename?: 'PlayerCodeListing';
    /** Acquisition mode: FREE, or a paid mode (BUY / RENT / TIME_LIMITED / COST_LIMITED; P4b). Free listings carry no price. */
    acquisitionMode: PlayerCodeAcquisitionMode;
    /** The listing's admission standing in this app. In implicit_allow apps this is always ADMITTED; in allow_list apps PENDING listings can be acquired but not installed. Null on management catalog reads that carry no app admission context. */
    admissionState: Maybe<PlayerCodeAdmissionState>;
    /** App the listing belongs to. */
    appId: Scalars['BigInt']['output'];
    /** When the listing was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Store description. */
    description: Scalars['String']['output'];
    /** UUID of the newest published version; null before first publish. */
    latestVersionId: Maybe<Scalars['String']['output']>;
    /** Source-access mode for new versions. */
    licenseMode: PlayerCodeLicenseMode;
    /** UUID of the listing. */
    listingId: Scalars['String']['output'];
    /** JSON array of media refs. */
    mediaJson: Scalars['String']['output'];
    /** Display name. */
    name: Scalars['String']['output'];
    /** Whether a player user or an org owns this listing. */
    ownerKind: PlayerCodeOwnerKind;
    /** User id or org id of the owner, per ownerKind. */
    ownerRef: Scalars['BigInt']['output'];
    /** Price in cents for paid modes; null when FREE. */
    priceCents: Maybe<Scalars['Int']['output']>;
    /** Rent billing interval in days (RENT mode). */
    rentIntervalDays: Maybe<Scalars['Int']['output']>;
    /** Catalog status (active / delisted / killed). */
    status: PlayerCodeListingStatus;
    /** Compute-unit budget per purchase (COST_LIMITED mode). */
    unitBudget: Maybe<Scalars['BigInt']['output']>;
    /** When the listing was last updated. */
    updatedAt: Maybe<Scalars['DateTime']['output']>;
    /** Fixed access window in days (TIME_LIMITED mode). */
    windowDays: Maybe<Scalars['Int']['output']>;
};
/** Catalog status of a listing: ACTIVE (browsable/acquirable), DELISTED (author withdrew it — existing installs keep their pinned versions), KILLED (studio/operator kill). */
export declare enum PlayerCodeListingStatus {
    Active = "ACTIVE",
    Delisted = "DELISTED",
    Killed = "KILLED"
}
/** An immutable published version of a code listing: artifact hashes (never source), explicit server-to-client requirements, and the DERIVED capability summary installers consent to. */
export type PlayerCodeListingVersion = {
    __typename?: 'PlayerCodeListingVersion';
    /** sha256 of the canonical capability summary. installPlayerCode and consentGridClientMod must echo this hash as the consent acknowledgement. */
    capabilityHash: Scalars['String']['output'];
    /** JSON capability summary DERIVED from the artifacts (host functions, capability groups, presentation hooks, triggers, egress budgets). Never self-declared; shown at acquire and install consent. */
    capabilitySummaryJson: Scalars['String']['output'];
    /** Client-target artifact hashes (empty for server-only listings). */
    clientArtifactHashes: Array<Scalars['String']['output']>;
    /** When the version was published. */
    createdAt: Maybe<Scalars['DateTime']['output']>;
    /** Author license terms shown at acquisition. */
    licenseText: Maybe<Scalars['String']['output']>;
    /** UUID of the listing. */
    listingId: Scalars['String']['output'];
    /** Whether this version’s source is open (irreversible per version). */
    openSource: Scalars['Boolean']['output'];
    /** Explicit SERVER artifact to required CLIENT artifact edges. Every referenced hash is a member of this immutable bundle. */
    requirements: Array<PlayerCodeRequirement>;
    /** Server-target artifact hashes (empty for client-only listings). */
    serverArtifactHashes: Array<Scalars['String']['output']>;
    /** UUID of this published version. */
    versionId: Scalars['String']['output'];
    /** Monotonic version number within the listing. */
    versionNo: Scalars['Int']['output'];
};
/** Who owns a marketplace code listing: a player user or an org (DN-9: the org then holds source access and listing control). */
export declare enum PlayerCodeOwnerKind {
    Org = "ORG",
    User = "USER"
}
/** One explicit edge from a server artifact to the client artifact it requires within the same immutable marketplace bundle. */
export type PlayerCodeRequirement = {
    __typename?: 'PlayerCodeRequirement';
    /** Artifact hash of the CLIENT half required by that server. */
    clientArtifactHash: Scalars['String']['output'];
    /** Artifact hash of the SERVER half declaring the requirement. */
    serverArtifactHash: Scalars['String']['output'];
};
/** An immutable published version of a code listing. Snapshots ARTIFACT HASHES and explicit server-to-client requirements from the author’s compiled module versions — never source (OQ-1). */
export type PlayerCodeVersion = {
    __typename?: 'PlayerCodeVersion';
    /** Numeric app id (denormalized from the listing). */
    appId: Scalars['BigInt']['output'];
    /** sha256 of the canonical capability summary. Installs record the hash they consented to; a widened summary on a newer version forces re-consent. */
    capabilityHash: Scalars['String']['output'];
    /** JSON capability summary DERIVED from the artifacts by the compile pipeline (imported host families, invoke contracts, presentation hooks, egress budgets). Never self-declared; this is what installers consent to. */
    capabilitySummaryJson: Scalars['String']['output'];
    /** Artifact hashes of the client-target modules in this version (empty for server-only listings). */
    clientArtifactHashes: Array<Scalars['String']['output']>;
    /** When the version was published. */
    createdAt: Scalars['DateTime']['output'];
    /** Author license terms shown at acquisition (platform enforces access, not downstream legal terms). */
    licenseText: Maybe<Scalars['String']['output']>;
    /** UUID of the listing this version belongs to. */
    listingId: Scalars['String']['output'];
    /** Whether this version’s source is open. Open-sourcing a version is irreversible for that version; later versions may return to closed. */
    openSource: Scalars['Boolean']['output'];
    /** Explicit SERVER artifact to required CLIENT artifact edges. Every referenced hash is a member of this immutable bundle. */
    requirements: Array<PlayerCodeRequirement>;
    /** Artifact hashes of the server-target modules in this version (empty for client-only listings). */
    serverArtifactHashes: Array<Scalars['String']['output']>;
    /** UUID of this published version. */
    versionId: Scalars['String']['output'];
    /** Monotonic version number within the listing. */
    versionNo: Scalars['Int']['output'];
};
/** Synchronous result from invoking an admitted server player-module export as the current grid owner. */
export type PlayerComputeInvokeResult = {
    __typename?: 'PlayerComputeInvokeResult';
    /** Wall-clock execution duration in µs. */
    durationUs: Scalars['Int']['output'];
    /** Instrumented fuel consumed. */
    fuelUsed: Scalars['BigInt']['output'];
    /** Raw module result bytes encoded as base64. */
    resultBase64: Scalars['String']['output'];
    /** UTF-8 result when it is valid JSON; otherwise null. */
    resultJson: Maybe<Scalars['String']['output']>;
};
/** A kill-ladder switch row (03 §7): a studio-set immediate stop at player, grid, app, or listing scope. Module-level disable lives on the module itself; killing a LISTING disables every install of that marketplace listing fleet-wide (P4a). Quota state is retained across a kill. */
export type PlayerComputeSwitch = {
    __typename?: 'PlayerComputeSwitch';
    /** The app the switch applies to. */
    appId: Scalars['BigInt']['output'];
    /** When execution was stopped. */
    disabledAt: Scalars['DateTime']['output'];
    /** The marketplace listing UUID for listing scope; null otherwise. */
    listingRef: Maybe<Scalars['String']['output']>;
    /** Operator note recorded when the switch was thrown. */
    reason: Maybe<Scalars['String']['output']>;
    /** Scope: 'player', 'grid', 'app', or 'listing'. */
    scope: Scalars['String']['output'];
    /** The player user id or grid id; null for app and listing scopes. */
    scopeRef: Maybe<Scalars['BigInt']['output']>;
    /** Switch row UUID. */
    switchId: Scalars['String']['output'];
};
/** Execution target for player-authored Rust. SERVER runs as the grid owner in game-api; CLIENT runs as the actual player in the browser worker sandbox. */
export declare enum PlayerComputeTarget {
    Client = "CLIENT",
    Server = "SERVER"
}
/** The caller's player-compute spend and quota view for one app (P2): unit usage in the current clock hour/day, the effective policy limits, compile-quota utilization, and the replica-synced wallet/spend-cap gate state. Units follow the platform formula GREATEST(cpu ms, fuel/22M); player automation units are included. */
export type PlayerComputeUsage = {
    __typename?: 'PlayerComputeUsage';
    /** The app this view covers. */
    appId: Scalars['BigInt']['output'];
    /** Compile submissions counted in the current clock hour. */
    compilesThisHour: Scalars['Int']['output'];
    /** Compute units consumed in the current clock day. */
    dayUnitsUsed: Scalars['BigInt']['output'];
    /** Typed pause reason when gated: PLAYER_WALLET_EMPTY, PLAYER_SPEND_CAP, PLAYER_QUOTA_EXHAUSTED, or PLAYER_COMPUTE_KILLED. */
    gateReason: Maybe<Scalars['String']['output']>;
    /** Replica-synced management player gate for this app: 'active', 'grace', or 'denied'. Non-active pauses this player's modules only; play is untouched. */
    gateStatus: Scalars['String']['output'];
    /** Compute units consumed in the current clock hour (modules + automations, all owned grids aggregated). */
    hourUnitsUsed: Scalars['BigInt']['output'];
    /** Effective max_compiles_per_hour policy cap. */
    maxCompilesPerHour: Scalars['Int']['output'];
    /** Effective units_per_day developer-policy cap; null when the app sets no daily quota. */
    unitsPerDay: Maybe<Scalars['BigInt']['output']>;
    /** Effective units_per_hour developer-policy cap; null when the app sets no hourly quota. */
    unitsPerHour: Maybe<Scalars['BigInt']['output']>;
};
/** What a player-facing surface may be told about a failure that came from code the platform did not write. Deliberately coarser than the internal fault taxonomy: it says what a player can act on and never names an engine, a module, a function or a limit. The full detail is in the developer surfaces (gameModelEvents, computeModuleRuns, userCodeFaults). */
export declare enum PlayerFaultCode {
    /** The app's datacenter has no instance able to serve clients. No endpoint is named, on purpose — there is nowhere to send the client. */
    AppUnavailable = "APP_UNAVAILABLE",
    /** A per-minute allowance for this app is spent; it returns on the next window. */
    BudgetExceeded = "BUDGET_EXCEEDED",
    /** The arguments did not satisfy the function's contract. */
    InvalidRequest = "INVALID_REQUEST",
    /** An invoke policy or permission refused this caller. */
    NotAllowed = "NOT_ALLOWED",
    /** The named function, module or export does not exist for this app. */
    NotFound = "NOT_FOUND",
    /** The platform could not start the work in time. The app's code never ran. Retrying is correct. */
    PlatformBusy = "PLATFORM_BUSY",
    /** A platform failure. Retrying is reasonable. */
    PlatformError = "PLATFORM_ERROR",
    /** A metered allowance is spent and does not return on its own. */
    QuotaExhausted = "QUOTA_EXHAUSTED",
    /** This caller is asking too often. It arrives ONLY as a thrown error, never in band on a result, and `extensions.retryAfterMs` carries the wait. That number is the milliseconds REMAINING in the current fixed window at the moment the refusal was built, not a fixed backoff, so a second refusal inside the same window carries a smaller number: treat it as a deadline from receipt and do not reuse a cached one. */
    RateLimited = "RATE_LIMITED",
    /** A breaker is open or an operator switch is off for this subject. */
    TemporarilyDisabled = "TEMPORARILY_DISABLED",
    /** No valid credential was presented. */
    Unauthenticated = "UNAUTHENTICATED",
    /** The app's own code failed while running. */
    UserCodeError = "USER_CODE_ERROR",
    /** The app's own code exceeded a per-call resource ceiling (gas, fuel, memory, depth, database operations, response size). */
    UserCodeLimitExceeded = "USER_CODE_LIMIT_EXCEEDED",
    /** The app's own code ran past the time it is allowed. */
    UserCodeTooSlow = "USER_CODE_TOO_SLOW",
    /** This app is served from another datacenter. The error extensions carry `gameApiUrl`; move there and retry. */
    WrongDatacenter = "WRONG_DATACENTER"
}
/**
 * Why an invocation failed, in the only vocabulary a player may be shown: a stable code, whose problem it is, and whether repeating the identical call could succeed. It carries no message, no engine name and no internal detail by design — blame attribution is the platform's job and presentation is the game's.
 *
 * IT CARRIES NO TIMING, AND NOTHING THAT NEEDS TIMING ARRIVES HERE. A refusal that can tell you how long to wait — `RATE_LIMITED` above all — is THROWN, with `extensions.retryAfterMs`, and never returned in band on a result. So `retryable: true` here means "try again", not "try again after N milliseconds", and a client with nothing but this object is right to use its own backoff. `expression-fault.classifier.spec.ts` holds that split rather than leaving it to how the code happens to be arranged.
 */
export type PlayerFaultInfo = {
    __typename?: 'PlayerFaultInfo';
    /** Whose problem this is. The one question a game cannot answer for itself. */
    blame: UserCodeFaultBlame;
    /** A stable, enumerated reason. Branch on this rather than on any text. */
    code: PlayerFaultCode;
    /** True when repeating the identical call could succeed with nothing else changing. About the caller's options, not about how long a fix takes: an open breaker is retryable because it closes itself, while a spent plan allowance is not. */
    retryable: Scalars['Boolean']['output'];
};
/** A flexible player-owned model container confined to exactly one app, grid, and current owner. */
export type PlayerModelContainer = {
    __typename?: 'PlayerModelContainer';
    /** App containing the container. */
    appId: Scalars['BigInt']['output'];
    /** Player container UUID. */
    containerId: Scalars['String']['output'];
    /** Container creation time. */
    createdAt: Scalars['DateTime']['output'];
    /** Optional player-facing name. */
    displayName: Maybe<Scalars['String']['output']>;
    /** Grid confining the container. */
    gridId: Scalars['BigInt']['output'];
    /** Owning user. Always the grid owner at creation time. */
    ownerUserId: Scalars['BigInt']['output'];
    /** JSON object containing all separately upserted properties. */
    propertiesJson: Scalars['String']['output'];
    /** JSON object containing untyped container state. */
    stateJson: Scalars['String']['output'];
    /** Flexible instance kit key; this is not a studio-authored type. */
    typeKey: Scalars['String']['output'];
    /** Most recent container or property update time. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Identify one player-owned model container within an app and grid. The server also forces the current caller as owner. */
export type PlayerModelContainerRefInput = {
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Player container UUID. */
    containerId: Scalars['String']['input'];
    /** Grid that confines the container. */
    gridId: Scalars['BigInt']['input'];
};
/** Live concurrent players for a studio vs its all-time peak, a percentile comparison against other studios, and the site-wide CKS total. */
export type PlayerPulse = {
    __typename?: 'PlayerPulse';
    /** Current concurrent players site-wide (dedicated environments plus active dev boxes). Aggregate-only; no per-studio breakdown. */
    globalLivePlayers: Scalars['Int']['output'];
    /** All-time peak concurrent players recorded for this org. */
    orgAllTimePeak: Scalars['Int']['output'];
    /** When the org all-time peak was observed. */
    orgAllTimePeakAt: Maybe<Scalars['DateTime']['output']>;
    /** Current concurrent players for this org (dedicated environments plus active dev boxes). */
    orgLivePlayers: Scalars['Int']['output'];
    /** Share of studios whose all-time peak is at or below this org (0–1). Null when the comparison pool is empty or this org has no peak. */
    percentile: Maybe<Scalars['Float']['output']>;
    /** Number of studios in the percentile comparison pool (studios with all_time_peak > 0). */
    poolSize: Scalars['Int']['output'];
};
/** The caller's per-app player runtime gate state (the app runtime_status twin, player-scoped): 'active', 'grace', or 'denied' with a typed reason. Non-active pauses the player's grid compute only — an unfunded wallet stops your mods, not your game. */
export type PlayerRuntimeState = {
    __typename?: 'PlayerRuntimeState';
    /** The app. */
    appId: Scalars['BigInt']['output'];
    /** PLAYER_WALLET_EMPTY or PLAYER_SPEND_CAP when not active. */
    reason: Maybe<Scalars['String']['output']>;
    /** 'active', 'grace', or 'denied'. */
    status: Scalars['String']['output'];
    /** Last gate evaluation that changed state. */
    updatedAt: Scalars['DateTime']['output'];
    /** The player user id. */
    userId: Scalars['BigInt']['output'];
};
/** A player's self-set spend cap (06 §2a): a daily/monthly ceiling globally or per app. The effective runtime limit is min(developer policy, self-cap, wallet balance); hitting a cap pauses that player's mods with PLAYER_SPEND_CAP, never their play. */
export type PlayerSpendCap = {
    __typename?: 'PlayerSpendCap';
    /** Spend counted against the daily cap so far today. */
    currentDayUsageCents: Scalars['BigInt']['output'];
    /** Spend counted against the monthly cap so far this month. */
    currentMonthUsageCents: Scalars['BigInt']['output'];
    /** Daily ceiling in cents; null = no daily cap. */
    dailyLimitCents: Maybe<Scalars['BigInt']['output']>;
    /** Calendar-month ceiling in cents; null = no monthly cap. */
    monthlyLimitCents: Maybe<Scalars['BigInt']['output']>;
    /** Cap scope: 'global' or 'app'. */
    scope: Scalars['String']['output'];
    /** The app id for app scope; null for global. */
    scopeRef: Maybe<Scalars['BigInt']['output']>;
    /** The owning player user id. */
    userId: Scalars['BigInt']['output'];
};
/** One posted player usage charge: a (player, app, closed clock hour) row. amountCents = platformCents + markupCents — players see what the platform charges and what the studio adds (06 §4). The UNIQUE hour key makes the billing tick idempotent. */
export type PlayerUsageCharge = {
    __typename?: 'PlayerUsageCharge';
    /** Total debited cents. */
    amountCents: Scalars['BigInt']['output'];
    /** The app the usage ran in. */
    appId: Scalars['BigInt']['output'];
    /** Charge id. */
    chargeId: Scalars['BigInt']['output'];
    /** When the charge posted. */
    createdAt: Scalars['DateTime']['output'];
    /** ISO currency code. */
    currency: Scalars['String']['output'];
    /** Studio markup component (the app's player_rate_markup_bps). */
    markupCents: Scalars['BigInt']['output'];
    /** Billed hour end (exclusive). */
    periodEnd: Scalars['DateTime']['output'];
    /** Billed hour start (inclusive). */
    periodStart: Scalars['DateTime']['output'];
    /** Platform component (base rate card). */
    platformCents: Scalars['BigInt']['output'];
    /** JSON per-metric usage/billing snapshot for the hour. */
    usageSnapshotJson: Scalars['String']['output'];
    /** The owning player user id. */
    userId: Scalars['BigInt']['output'];
};
/** The caller's player wallet (player compute P2, DN-5): a platform-scoped balance funding that player's grid compute across every org/app they play in. Out-of-band from org wallets — player usage never touches an org's money. */
export type PlayerWallet = {
    __typename?: 'PlayerWallet';
    /** Current balance in cents (may go negative on a closed hour). */
    balanceCents: Scalars['BigInt']['output'];
    /** Wallet creation time. */
    createdAt: Scalars['DateTime']['output'];
    /** ISO currency code (lowercase). */
    currency: Scalars['String']['output'];
    /** The owning player user id. */
    userId: Scalars['BigInt']['output'];
    /** Wallet id. */
    walletId: Scalars['BigInt']['output'];
};
/** One player-wallet ledger entry: top-ups, hourly usage debits, auto-recharges, refunds, and adjustments. Usage debits carry the app and reference the hour's charge row, whose snapshot splits platform vs studio-markup components. */
export type PlayerWalletTransaction = {
    __typename?: 'PlayerWalletTransaction';
    /** Signed amount in cents (debits negative). */
    amountCents: Scalars['BigInt']['output'];
    /** The app a usage debit covers; null for wallet-level entries. */
    appId: Maybe<Scalars['BigInt']['output']>;
    /** Balance after this entry. */
    balanceAfter: Scalars['BigInt']['output'];
    /** Entry time. */
    createdAt: Scalars['DateTime']['output'];
    /** Human description. */
    description: Maybe<Scalars['String']['output']>;
    /** External reference (checkout/PaymentIntent id). */
    referenceId: Maybe<Scalars['String']['output']>;
    /** Transaction id. */
    transactionId: Scalars['BigInt']['output'];
    /** What produced this entry. The complete set of values this API writes: "topup" (credit from a completed checkout, positive), "auto_recharge" (off-session automatic recharge, positive), "payout_credit" (marketplace seller payout, positive), "refund" (marketplace refund returned to the buyer, positive), "usage_debit" (hourly player-compute metered charge for one closed clock hour, negative), "purchase" (marketplace purchase, negative), "adjustment" (operator or dispute-clawback correction, signed). */
    transactionType: Scalars['String']['output'];
    /** The owning player user id. */
    userId: Scalars['BigInt']['output'];
    /** The wallet. */
    walletId: Scalars['BigInt']['output'];
};
/** A grid-bound player compute module. Runtime identity is never stored here; it resolves from the grid current owner at activation. */
export type PlayerWasmModule = {
    __typename?: 'PlayerWasmModule';
    /** Owning app id. */
    appId: Scalars['BigInt']['output'];
    /** Authoring org id; null for personally-authored code. */
    authorOrgId: Maybe<Scalars['BigInt']['output']>;
    /** Personal author user id; null for org-owned code. */
    authorUserId: Maybe<Scalars['BigInt']['output']>;
    /** closed, open, or half_open. */
    circuitState: Scalars['String']['output'];
    /** Creation time. */
    createdAt: Scalars['DateTime']['output'];
    /** Target of the current immutable version, or null before the first deploy. */
    currentTarget: Maybe<PlayerComputeTarget>;
    /** Currently deployed immutable version UUID. */
    currentVersionId: Maybe<Scalars['String']['output']>;
    /** Module description. */
    description: Maybe<Scalars['String']['output']>;
    /** Draft mode: the module runs for its author but its spatial egress is suppressed server-side (live-coding iteration). */
    draft: Scalars['Boolean']['output'];
    /** Requested activation state. Actual execution also requires grid ownership, run permission, admission, and a successful version. */
    enabled: Scalars['Boolean']['output'];
    /** Confining grid id. */
    gridId: Scalars['BigInt']['output'];
    /** Last runtime/transfer error. */
    lastError: Maybe<Scalars['String']['output']>;
    /** Module UUID. */
    moduleId: Scalars['String']['output'];
    /** Module name within the grid. */
    name: Scalars['String']['output'];
    /** Last update time. */
    updatedAt: Scalars['DateTime']['output'];
};
/** One execution of a player module (init/tick/invoke/event), attributed to the grid owner it ran as. The per-run twin of the studio WasmModuleRun, scoped to grids the caller currently owns. */
export type PlayerWasmModuleRun = {
    __typename?: 'PlayerWasmModuleRun';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** Wall-clock duration in microseconds. */
    durationUs: Scalars['Int']['output'];
    /** Typed failure kind when the run failed. */
    errorMessage: Maybe<Scalars['String']['output']>;
    /** Execution identity: the grid owner the run executed as. */
    executedAsUserId: Scalars['BigInt']['output'];
    /** Flow correlation id shared across the entry call. */
    flowId: Maybe<Scalars['String']['output']>;
    /** Fuel consumed by the run. */
    fuelUsed: Scalars['BigInt']['output'];
    /** The owned grid the module ran in. */
    gridId: Scalars['BigInt']['output'];
    /** The module that ran. */
    moduleId: Scalars['String']['output'];
    /** The module name at run time. */
    moduleName: Scalars['String']['output'];
    /** Unique run id (UUID). */
    runId: Scalars['String']['output'];
    /** When the run started. */
    startedAt: Scalars['DateTime']['output'];
    /** Whether the run succeeded. */
    success: Scalars['Boolean']['output'];
    /** What ran: init | tick | event | invoke. */
    triggerSource: Scalars['String']['output'];
};
/** An immutable player-code source version. sourceFilesJson is returned only to its personal author (org-owned source requires the future org-authoring path) or when openSource is true. */
export type PlayerWasmModuleVersion = {
    __typename?: 'PlayerWasmModuleVersion';
    /** Compiler log; visible to the author. */
    compileLog: Maybe<Scalars['String']['output']>;
    /** pending, compiling, succeeded, or failed. */
    compileStatus: Scalars['String']['output'];
    /** Final instrumented/optimized artifact size. */
    compiledSizeBytes: Maybe<Scalars['BigInt']['output']>;
    /** Version creation time. */
    createdAt: Scalars['DateTime']['output'];
    /** Parent module UUID. */
    moduleId: Scalars['String']['output'];
    /** Whether anyone may read this immutable version source. */
    openSource: Scalars['Boolean']['output'];
    /** JSON source map. Null for non-authors of closed-source code; P1 exposes no moderation override. */
    sourceFilesJson: Maybe<Scalars['String']['output']>;
    /** Compile target. */
    target: PlayerComputeTarget;
    /** Version UUID. */
    versionId: Scalars['String']['output'];
    /** Monotonic version number. */
    versionNo: Scalars['Int']['output'];
};
/** One player-compute policy row (06 §3): developer-set per-player/cohort clamps evaluated most-specific-wins (user > grid > tier > app_default), every knob additionally clamped by the app's studio policy at runtime. Management is authoritative in P2; rows replica-sync to the game runtime. */
export type PlayerWasmPolicy = {
    __typename?: 'PlayerWasmPolicy';
    /** The app. */
    appId: Scalars['BigInt']['output'];
    /** Client-target fuel budget per browser dispatch (04 §3). */
    clientFuelPerDispatch: Scalars['BigInt']['output'];
    /** Whether this row is applied. */
    enabled: Scalars['Boolean']['output'];
    /** Fuel budget per invoke/event. */
    fuelPerInvoke: Scalars['BigInt']['output'];
    /** Fuel budget per tick. */
    fuelPerTick: Scalars['BigInt']['output'];
    /** Deploys (compiles) allowed per player per hour. */
    maxCompilesPerHour: Scalars['Int']['output'];
    /** Player model containers created per player per day. */
    maxContainerCreatesDay: Scalars['Int']['output'];
    /** Host data-API ops per tick. */
    maxDbOpsPerTick: Scalars['Int']['output'];
    /** Module replication bytes per minute. */
    maxEgressBytesPerMin: Scalars['BigInt']['output'];
    /** Module replication messages per minute. */
    maxEgressMsgsPerMin: Scalars['Int']['output'];
    /** Sandbox memory ceiling (MiB). */
    maxMemoryMb: Scalars['Int']['output'];
    /** Max player modules per grid. */
    maxModulesPerGrid: Scalars['Int']['output'];
    /** Max player modules across all grids one player owns. */
    maxModulesTotal: Scalars['Int']['output'];
    /** Watchdog wall-clock ceiling (ms). */
    maxRunMs: Scalars['Int']['output'];
    /** Max tick rate in Hz. */
    maxTickHz: Scalars['Float']['output'];
    /** Policy row UUID. */
    policyId: Scalars['String']['output'];
    /** 'app_default', 'tier', 'grid', or 'user'. */
    scope: Scalars['String']['output'];
    /** Tier/grid/user id; null for app_default. */
    scopeRef: Maybe<Scalars['BigInt']['output']>;
    /** Daily compute-unit quota; null = uncapped. */
    unitsPerDay: Maybe<Scalars['BigInt']['output']>;
    /** Hourly compute-unit quota (PLAYER_QUOTA_EXHAUSTED pause); null = uncapped. */
    unitsPerHour: Maybe<Scalars['BigInt']['output']>;
};
/** A one-time portal authorization code. Redirect the player to `redirectUri` carrying `code`; the destination game exchanges it (with its PKCE verifier) via exchangePortalCode for an app token. Single-use and short-lived. */
export type PortalAuthorizationCode = {
    __typename?: 'PortalAuthorizationCode';
    /** The one-time authorization code. Deliver it to the destination game origin only (e.g. as a `code` query param on redirectUri). */
    code: Scalars['String']['output'];
    /** ISO-8601 UTC expiry of the code (typically ~60s). */
    expiresAt: Scalars['String']['output'];
    /** 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'];
};
/** Result of publishing an app to the shared environment. All paths publish immediately; usage above the free hourly allowance is wallet-billed. */
export type PublishAppResult = {
    __typename?: 'PublishAppResult';
    appId: Scalars['BigInt']['output'];
    /** @deprecated Always null — subscriptions replaced by wallet billing. */
    checkout: Maybe<Checkout>;
    /** True when the app uses a free org app-slot (under the quota). */
    free: Scalars['Boolean']['output'];
};
/** Publish a new immutable Crowdy Studio-curated common-file version. Requires the app manage_compute permission. */
export type PublishCrowdyStudioCommonFileInput = {
    /** App tenant receiving the common entry; the token and manage_compute permission must cover this app. */
    appId: Scalars['BigInt']['input'];
    /** Existing common entry UUID to version; omit to create or version by slug. */
    commonFileId?: InputMaybe<Scalars['String']['input']>;
    /** UTF-8 source text for the new immutable version, capped at 64 KiB. */
    content: Scalars['String']['input'];
    /** Optional Crowdy Studio-authored catalog description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Optional 24-hour retry key; strongly recommended to avoid duplicate versions after transport retries. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Safe recommended destination path. */
    path: Scalars['String']['input'];
    /** Stable lowercase hyphenated catalog slug. Existing entries cannot change their slug. */
    slug: Scalars['String']['input'];
    /** Optional unique lowercase discovery tags; at most 16. */
    tags?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Compatible project target for this common file. */
    target: CrowdyStudioTarget;
    /** Crowdy Studio-authored catalog title. */
    title: Scalars['String']['input'];
};
export type PublishPlayerCodeInput = {
    /** App the listing belongs to. */
    appId: Scalars['BigInt']['input'];
    /** Store description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Default source-access mode for new versions (default CLOSED). */
    licenseMode?: InputMaybe<PlayerCodeLicenseMode>;
    /** JSON array of media refs for store display. */
    mediaJson?: InputMaybe<Scalars['String']['input']>;
    /** Listing display name (unique per app among live listings). */
    name: Scalars['String']['input'];
    /** Publish under this org (DN-9 org-owned code: the org then holds source access and listing control). Requires manage_compute in that org. Omit to publish personally. */
    ownerOrgId?: InputMaybe<Scalars['BigInt']['input']>;
};
export type PublishPlayerCodeVersionInput = {
    /** App the listing belongs to. */
    appId: Scalars['BigInt']['input'];
    /** Author license terms shown at acquisition. */
    licenseText?: InputMaybe<Scalars['String']['input']>;
    /** UUID of the listing to publish under. */
    listingId: Scalars['String']['input'];
    /** UUIDs of the caller-authored, successfully compiled player module versions to package. Server and client versions may be combined into a bundle. The publish pipeline snapshots artifact hashes and the derived capability summary — never source. */
    moduleVersionIds: Array<Scalars['String']['input']>;
    /** Open-source this published version (irreversible for the version). */
    openSource?: InputMaybe<Scalars['Boolean']['input']>;
};
export type Query = {
    __typename?: 'Query';
    /** List only healthy GraphQL API servers (status = ReadyForClients) for client routing/discovery. No authentication required. */
    activeGraphQLServers: Array<GraphQlServer>;
    /** Fetches a single actor by its 32-character ASCII `uuid`. 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 uuid does not exist. */
    actor: Actor;
    /** Lists actors owned by the authenticated user, optionally narrowed by `filter` (appId, avatarId, uuid, chunk). Requires a valid game token; only the caller’s own actors are returned (full state included). For other users’ actors use `actor` or `batchLookupActors`. */
    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. */
    appAccessTiers: Array<AppAccessTier>;
    /** Returns the monthly spend cap and current-month usage for a single app, or null if no budget has been configured for it. Requires the 'view_billing' app permission. */
    appBudget: Maybe<AppBudget>;
    /** Lists every app spend-cap budget configured under the organization. Requires the 'view_billing' org permission. */
    appBudgets: Array<AppBudget>;
    /** Look up a single app by its org slug + app slug (the marketplace URL path). PUBLIC: no authentication required, and NOT filtered by visibility/status, so it can resolve unlisted or draft apps when the exact slugs are known. Returns null if no matching app exists. */
    appBySlug: Maybe<App>;
    /** Read an app's player-code admission mode. Requires 'view_compute_diagnostics'. IMPLICIT_ALLOW (the default) admits lawful player code without curation; ALLOW_LIST requires every running server/client artifact, including self-authored code, to match an active code, author, or org admission. */
    appCodeAdmissionMode: CodeAdmissionMode;
    /** The app's admission queue: every non-killed listing joined with its allow-list standing (ADMITTED via a matching code/author/org admission, PENDING, or REVOKED). Requires 'view_compute_diagnostics'. In allow_list apps PENDING listings are browsable but uninstallable; admit them via admitAppCode (subject kind CODE for one listing, AUTHOR or ORG for wholesale admission). */
    appCodeAdmissionQueue: Array<PlayerCodeAdmissionQueueEntry>;
    /** List an app's player-code admission entries, newest first. Requires 'view_compute_diagnostics'. By default returns active entries only; includeRevoked adds audit-visible revoked rows. Admission controls execution, never source visibility. */
    appCodeAdmissions: Array<AppCodeAdmission>;
    /** An app's stored compute allowance, or null when none has been set — in which case the app is measured against the platform reference allowance and is never refused. Requires app-admin ('manage_apps'). */
    appComputeBudget: Maybe<AppComputeBudgetInfo>;
    /** Whether an app is inside its per-minute compute allowance right now, which engines its units came from, and whether exceeding the allowance is currently refusing invokes or only being recorded. Shipped in shadow mode: unless an operator has set an enforcing allowance for this app, overBudget can be true while enforced is false. Requires app-admin ('manage_apps'). */
    appComputeBudgetStatus: AppComputeBudgetStatus;
    /** What an app consumed, in compute units, split by engine — the model expression engine, developer compute modules, and player compute — over a window of minutes. ONE unit spans them: a compute unit is one millisecond of measured execution time, which both engines already measure with the same clock, floored per engine by that engine's own work counter where the clock cannot see the work (fuel for WASM). Use peakMinuteUnits, not meanUnitsPerMinute, when comparing against a per-minute allowance. Requires app-admin ('manage_apps'). */
    appComputeUsage: AppComputeUsage;
    /** Resolve where one or more apps are placed, WITHOUT authenticating. Call this before login and connect to the returned gameApiUrl, so the session and app token are both written in the app's own datacenter instead of across a WAN. Pass every app a launcher might switch to and cache the result; placement changes rarely and only an operator can change it. An app with no placement comes back with nulls, which means 'keep using the shared origin'. */
    appDiscovery: Array<AppDiscovery>;
    /** Lists org members eligible for a manual app access grant (active members of the app's owning org). Requires the 'manage_access_tiers' permission on the app; super admins bypass. Use the returned user ids with grantAppAccess. */
    appGrantMemberCandidates: Array<AppGrantMemberCandidate>;
    /** Top GraphQL operations for an app ranked by bytes over the time range. Read-only reporting; the app must be linked to an environment in the org. Requires the 'view_usage' org permission. */
    appGraphqlOperations: Array<GraphqlOperationUsageRow>;
    /** List an app's code acquisitions (entitlement rows), newest first. Requires 'view_compute_diagnostics'. All rows are mode FREE in P4a; uninstalls never delete acquisitions (audit). */
    appPlayerCodeAcquisitions: Array<PlayerCodeAcquisition>;
    /** List the immutable published versions of a listing, newest first. Requires 'view_compute_diagnostics'. Versions expose artifact hashes and the derived capability summary — never source. */
    appPlayerCodeListingVersions: Array<PlayerCodeVersion>;
    /** List an app's marketplace code listings (studio administration view), newest first. Requires 'view_compute_diagnostics'. includeDelisted adds delisted/killed rows for moderation history. */
    appPlayerCodeListings: Array<PlayerCodeListing>;
    /** Total player rate-card markup accrued to this app's org income line, in cents (payouts arrive with the P4b ledger). Requires 'view_billing'. */
    appPlayerMarkupAccrued: Scalars['BigInt']['output'];
    /** Per-player usage aggregate for an app over a trailing window (top spenders / quota utilization, 06 §5): compute units, automation units, compiles, and cents charged per player. Requires 'view_compute_diagnostics'. */
    appPlayerUsage: Array<AppPlayerUsageRow>;
    /** Shared-environment runtime gate decision plus current hour/day billing-window usage for an app. Read this to learn why an app is not running (runtimeDenialReason). Caller must be a member of the app's org. */
    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. */
    appUserAccessByApp: Array<AppUserAccess>;
    /** 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. Relay cursor connection; prefer this over the offset-based appUserAccessByApp. */
    appUserAccessConnection: AppUserAccessConnection;
    /** Public marketplace listing of apps. PUBLIC: no authentication required. Returns ONLY apps with visibility=PUBLIC AND status=LIVE (drafts, unlisted, private, and archived apps are never returned). Use myApps or appsForOrg for caller-visible or org-scoped apps. Results are ordered newest-first and paginated via pageInfo. */
    apps: AppsPage;
    /** Public marketplace listing of apps. PUBLIC: no authentication required. Returns ONLY apps with visibility=PUBLIC AND status=LIVE (drafts, unlisted, private, and archived apps are never returned). Results are ordered newest-first. Relay cursor connection; prefer this over the offset-based apps. */
    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. */
    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. */
    avatarAppState: Maybe<AppAvatarState>;
    /** Batch-reads per-app state for many avatars under a single app in one call. PUBLIC READ: any authenticated user may read. Requires a valid game token. Avatars with no row for the app are omitted. `state` blobs are base64-encoded binary. */
    avatarAppStates: Array<AppAvatarState>;
    /** Bulk-fetches actors by a list of 32-character ASCII uuids in one round-trip. Requires a valid game token. PUBLIC-STATE ONLY: `privateState` is stripped (null) for every result regardless of ownership. Unknown uuids are silently omitted. Use this to resolve many actors at once; use `actor` for a single owner-scoped fetch. */
    batchLookupActors: Array<Actor>;
    /** OPERATOR ONLY. Every organization currently marked billing_exempt. An exemption nobody can enumerate is an exemption that outlives its reason. */
    billingExemptOrgs: Array<BillingExemptOrgType>;
    /** OPERATOR ONLY. The metered rate card for a scope: every priced dimension with its unit, price and hourly free allowance. SHARED is organization usage billed to the org wallet as "shared_usage"; PLAYER is player compute billed to the player wallet as "usage_debit". A dimension priced at 0 is metered but not charged. Read-only. */
    billingRateCard: Array<RateCardEntryType>;
    /** Fetch one channel by id. Errors if the id is not a channel. */
    channel: Group;
    /** List the members of a channel (the subscriber set, including pending requests), each with their status and roles. */
    channelMembers: Array<GroupMember>;
    /** The current channel creation/membership policy for an app (who may create channels and the default membership policy of new channels). Falls back to app defaults when unset. */
    channelPolicy: AppGroupPolicy;
    /** List the roles of a channel, including the system 'leader' role and any default 'member' role (which typically grants send_messages). */
    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. */
    checkoutsConnection: CheckoutsConnection;
    /** The app's open T11 commerce risk queue (velocity holds, same-party flags, chargebacks). Requires 'manage_compute'. */
    commerceRiskQueue: Array<CommerceRiskFlag>;
    /** A snapshot of an app's compute footprint: module/version/trigger counts plus 24h run activity and the most-active modules. Requires the org 'view_compute_diagnostics' permission. */
    computeAppDiagnostics: WasmAppDiagnostics;
    /** Read one compute module by name. Requires the org 'view_compute_diagnostics' permission. */
    computeModule: WasmModule;
    /** Diagnostic log lines for an app's compute modules, newest first: failed-run errors from the runtime plus guest ck.log output. Complete across the fleet — each line carries the instance that produced it. Requires the org 'view_compute_diagnostics' permission. */
    computeModuleLogs: Array<WasmModuleLogEntry>;
    /** Read the app's compute policy (platform defaults when unset). Requires the org 'view_compute_diagnostics' permission. */
    computeModulePolicy: WasmModulePolicy;
    /** List compute-module runs (the monitoring + audit trail of executions), newest first, optionally filtered by module and/or outcome. Rows are written by the runtime; empty until modules execute (Phase 2). Requires the org 'view_compute_diagnostics' permission. */
    computeModuleRuns: Array<WasmModuleRun>;
    /** Aggregate compute activity for an app over a recent window: run/failure counts, fuel, egress, and a per-module breakdown. Requires the org 'view_compute_diagnostics' permission. */
    computeModuleStats: WasmComputeStats;
    /** List trigger bindings for an app, optionally filtered to one module. Requires the org 'view_compute_diagnostics' permission. */
    computeModuleTriggers: Array<WasmModuleTrigger>;
    /** List a module's source versions, newest first, including compile status/logs. Requires the org 'view_compute_diagnostics' permission. */
    computeModuleVersions: Array<WasmModuleVersion>;
    /** List the compute modules defined for an app. Requires the org 'view_compute_diagnostics' permission. */
    computeModules: Array<WasmModule>;
    /** The platform's engine-template registry: ready-made compute engines (mob/world/match/deck/instance/director/matchmaking/market/board/minigame/abilities/movement-warden/territory/racing/...) deployable by name with computeDeployTemplate. Requires the org 'manage_compute' permission. */
    computeTemplates: Array<ComputeTemplateInfo>;
    /** Operator only (is_operator). The stored platform ceilings for the per-app WASM compute policy (the knobs computeSetPolicy clamps against). Null fields mean no operator override: game-api uses its COMPUTE_PLATFORM_MAX_* env var, then the code default. Read-only. */
    cpComputePlatformCeilings: CpComputePlatformCeilings;
    /** Operator only (is_operator or is_super_admin). What the ANSWERING ck-api instance carries for Agentic Studio: allowlisted models with their pinned micro-USD prices, the implemented crowdy.agent-tools/1 tools with risk classes, and the complete mode and risk-class value sets a policy may draw from. It is deployed configuration read from that one process, not stored policy and not a fleet-wide claim, so it reports which instance and datacenter answered. A platform policy may name a model or tool absent here: the write succeeds, the value is stored and echoed back, and no run can use it. */
    cpCrowdyStudioAgentCatalog: CrowdyStudioAgentCatalog;
    /** Operator only (is_operator or is_super_admin). Read the platform Agentic Studio enablement, global emergency kill, model/tool/mode/risk allowlists, budget ceilings, retention/privacy policy, pilot funding seam, timestamps, and revision. No provider credential or request body is stored or returned. */
    cpCrowdyStudioAgentPlatformPolicy: CrowdyStudioAgentPolicy;
    /** Return every effective TURN, SESSION, and PLAYER_DAY request/token/reasoning/cost/tool-round/wall-clock/tool-call/compile dimension with reserved, consumed, and non-negative remaining values. The pilot is platform-funded and this owner/app query never debits a wallet. */
    crowdyStudioAgentBudget: AgentBudget;
    /** Read Management's fail-closed Agentic Crowdy Studio publication: platform enable/kill, per-app operator kill, app enable/kill, the resolved model/tool/mode/risk lists (models and modes are the platform/app intersection; a tool or risk list the app left empty is inherited from the platform whole, because empty at a layer that can only narrow means no narrowing), minimum budgets/retention, locked privacy, and platform-funded billing seam. Requires 'view_compute_diagnostics'. This is the source publication, not proof of current runtime enforcement: Game API must hold a fresh crowdy.studio-agent-policy/1 replica and independently enforce it; missing/stale/malformed replica or an empty model/mode intersection must disable the agent. */
    crowdyStudioAgentEffectivePolicy: CrowdyStudioAgentPolicy;
    /** Replay ordered durable typed events with seq greater than afterSeq. Requires the app-scoped owner and use_studio_agent. Use this query to fill subscription gaps; results are ascending, at-least-once safe, default 100, maximum 200. */
    crowdyStudioAgentHistory: AgentEventConnection;
    /** Read the app-owned Agentic Crowdy Studio policy row, or a disabled/killed deny-all projection when no row exists. Requires 'view_compute_diagnostics' on the app. This is configuration only: use crowdyStudioAgentEffectivePolicy to see platform clamp and kill precedence. No provider key, prompt, source, header, request/response body, payer reference, or other secret is exposed. */
    crowdyStudioAgentPolicy: CrowdyStudioAgentPolicy;
    /** Return one durable Agentic Crowdy Studio session plus its active run, leases, and pending approval. Requires an unexpired app-scoped token, use_studio_agent, and exact session owner/app visibility; missing and foreign ids return AGENT_SESSION_NOT_FOUND. */
    crowdyStudioAgentSession: AgentSession;
    /** List the authenticated owner’s Agentic Crowdy Studio sessions in one app using an opaque cursor, newest first. Requires an app-scoped token for appId and use_studio_agent. The bounded page defaults to 20 and allows 1–50. */
    crowdyStudioAgentSessions: AgentSessionConnection;
    /** Return only implemented tools allowed by the current mode plus the exact non-stale Management model/tool/risk policy. Each entry includes the complete canonical crowdy.agent-tool/1 descriptor and digest. Requires the app-scoped owner and use_studio_agent. */
    crowdyStudioAgentToolDescriptors: AgentToolDescriptorSet;
    /** Read the app's sanitized platform-funded Agentic Studio usage over a bounded time window. Requires 'view_compute_diagnostics'. Returns exact OpenRouter prompt/completion/reasoning/cache/native token and decimal-USD cost dimensions, request/tool/compile/wall counts, and pinned policy revisions. It never returns prompts, source, private reasoning, headers, provider bodies, credentials, payer references, or wallet data; pilot usage never debits a player wallet. */
    crowdyStudioAgentUsage: CrowdyStudioAgentUsagePage;
    /** List the current immutable versions of published Crowdy Studio-curated common files for one app. Requires an app-scoped token for appId; unlike private player source, this catalog content is intentionally readable by players in that app. Results are bounded and may be filtered by target. */
    crowdyStudioCommonFiles: Array<CrowdyStudioCommonFile>;
    /** List the authenticated player’s private reusable Crowdy Studio source files in one app. Requires an app-scoped token for appId; cross-user entries are never visible, including to grid owners or Crowdy Studio operators. The bounded result defaults to 50. */
    crowdyStudioLibraryFiles: Array<CrowdyStudioLibraryFile>;
    /** Load one private Crowdy Studio project with all bounded source files. Requires an app-scoped token for appId and exact caller ownership; missing, cross-app, and cross-user ids all return the same NOT_FOUND shape. Grid owners and Crowdy Studio operators receive no source override. */
    crowdyStudioProject: CrowdyStudioProject;
    /** List the authenticated player’s private Crowdy Studio projects in one app, newest first. Requires an app-scoped token for appId; every row and source-file read is filtered by both app and caller ownership. The bounded result defaults to 25 and never grants grid deployment authority. */
    crowdyStudioProjects: Array<CrowdyStudioProject>;
    /** Resolves the single most-specific quota that applies to the given (tierId, appId, orgId, metric) by walking tier -> app -> org -> free-tier defaults and returning the first match; its limitValue/period describe the enforced limit. Returns null if no matching rule and no free-tier default exist for the metric. Requires the 'view_usage' permission on the most-specific scope provided: tierId or appId -> 'view_usage' on the (owning) app; orgId -> 'view_usage' on the org. A metric-only query (no scope ids) resolves the platform free-tier default and only requires an authenticated user. */
    effectiveQuota: Maybe<ServiceQuota>;
    /** Operator only (is_operator). Everything this API knows about whether an address can be emailed: its stored status, whether its domain is suppressed, and the recent SES events for it (the `send` written when the message was handed to SES, and the `delivery` / `bounce` / `complaint` that came back on the SNS webhook). */
    emailDeliverability: EmailDeliverability;
    /** Operator only (is_operator). How THIS API instance is configured to send mail: whether sending is on, the From address, the SES configuration set, the region and the suppressed domains. Answers 'why did no email arrive' without an SSH session, and reports the instance that served the query rather than the fleet. */
    emailDeliveryConfig: EmailDeliveryConfig;
    /** Reports whether a free-play window is active now, a human-readable schedule description, and the ISO-8601 start of the next window. PUBLIC: no authentication required. Takes no arguments; computed from server config and the current clock. */
    freePlayWindowInfo: FreePlayWindowInfo;
    /** Single startup payload for browser game clients: the authenticated user, server/min-client version requirements, current UDP proxy status, realtime protocol details (subprotocol + subscription name), and the spatial send limits/constants (maxReplicationDistance, maxDecayRate, sequenceNumberModulo). Requires a bearer game token. Read-only: does not open a UDP proxy session. Call this once after login to initialize a play session. */
    gameClientBootstrap: GameClientBootstrap;
    /** Returns the single elected host user for an app (game). Deterministic across all game-api replicas behind the LB: the user whose earliest still-connected actor row was created first wins, with a uuid tiebreaker. Returns null when no actors exist for the app. Stale actors (no recent actorHeartbeat) are excluded once HOST_ACTOR_FRESHNESS_SECONDS is enabled. Clients should poll; there is no host-change subscription in v1. */
    gameHost: Maybe<GameHost>;
    /** Read the best-known app-scoped number of active gameplay sessions across fresh non-Offline Buddy servers. This counts sessions, not actors or distinct users. FRESH is a complete fleet total; PARTIAL is only the supported-Buddy subset; UNAVAILABLE has no fresh observation. Partial/unavailable samples never create count-change revisions. Requires an app-scoped token for this exact app. */
    gameModelActivePlayerCount: GameModelActivePlayerCountSnapshot;
    /** A snapshot of an app's game-model footprint and recent activity: container/property/edge/session/function/automation row counts, total + 24h event volume, failed + automation-driven invocations, and the most-invoked functions. Helps developers understand what is in their game and their database. Requires app-admin ('manage_apps'). */
    gameModelAppDiagnostics: GmAppDiagnostics;
    /** Fetch one automation by name, including its circuit-breaker state. Requires app-admin ('manage_apps'). */
    gameModelAutomation: GmAutomation;
    /** Read the app's automation policy (guardrails / platform ceilings). Requires app-admin ('manage_apps'). */
    gameModelAutomationPolicy: GmAutomationPolicy;
    /** List automation runs (the monitoring + audit trail of autonomous-process executions) for an app, newest first, optionally filtered by automation name and/or outcome. Each run carries timing, fan-out + invocation counts, billed compute, and any circuit action. Requires app-admin ('manage_apps'). */
    gameModelAutomationRuns: Array<GmAutomationRun>;
    /** Aggregate automation activity for an app over a recent window (default 60 minutes, max 1440): total/failed runs, failure rate, runs/min, invocations/mutations/compute, and a per-automation breakdown with current circuit state. The "what are my NPCs doing" dashboard query. Requires app-admin ('manage_apps'). */
    gameModelAutomationStats: GmAutomationStats;
    /** List automation event triggers for an app, optionally filtered to one automation (by name). Requires app-admin ('manage_apps'). */
    gameModelAutomationTriggers: Array<GmAutomationTrigger>;
    /** List the automations defined for an app. Requires app-admin ('manage_apps'). */
    gameModelAutomations: Array<GmAutomation>;
    /** Fetch one container (instance) by id. Requires a valid token. */
    gameModelContainer: GmContainer;
    /** Fetch a container with its property values filtered to what the CALLER may see (public always; owner/hidden depend on the caller's relationship to the container). Use this for a player-facing view of an entity. Requires a valid token. */
    gameModelContainerState: GmContainerState;
    /** List all container types defined for an app. Requires app-admin ('manage_apps'). */
    gameModelContainerTypes: Array<GmContainerType>;
    /** List containers in an app, optionally filtered by container type and/or session, by bindingKey (get-by-key read of an ensured container), by property predicates (`where`, requires typeName; the same predicate shape automation selectors use — missing properties fall back to the type default), and paged with offset/limit over the stable created-at ordering. Requires a valid token. */
    gameModelContainers: Array<GmContainer>;
    /** Query the function-invocation event log (audit trail) with optional filters and pagination. Useful for debugging functions or showing recent activity. Requires a valid token. */
    gameModelEvents: Array<GmEvent>;
    /** Relay-style cursor-paginated version of `gameModelEvents`: query the function-invocation event log (audit trail) with optional filters. Page forward with `first` (default 50, max 200) and `after` (an opaque cursor from a previous page’s `pageInfo.endCursor`), which replace the legacy `limit`/`offset`. Useful for debugging functions or showing recent activity. Requires a valid token. */
    gameModelEventsConnection: GameModelEventsConnection;
    /** List the feature keys defined for an app. Requires app-admin ('manage_apps'). */
    gameModelFeatures: Array<GmAppFeature>;
    /** Diagnostics surface: stitch one flow correlation id into a single cross-engine timeline — the model events (gm event log), automation runs, and compute module runs that share the flowId minted at the entry edge (player gameModelInvoke / automation run / computeInvoke) and propagated across model_invoke, the event bus, and emit_compute_event. Each array is ordered by time ascending; an unknown flowId returns three empty arrays. Answers "what happened to this kill's reward" in one query instead of three hand-joined ones. Requires app-admin ('manage_apps'). */
    gameModelFlow: GmFlowTimeline;
    /** Fetch one studio-defined function by name. Requires app-admin ('manage_apps'). */
    gameModelFunction: GmFunction;
    /** State of the per-function circuit breaker on the player-invoke path (gameModelInvoke) for one app, plus the mode and thresholds the answering instance is running. In the default 'shadow' mode nothing is refused and shadowRefusals counts what enforcement would have refused, so an open circuit means the function has been failing rather than that players are being blocked. A function that has never failed has no row and is absent. Requires the org 'view_compute_diagnostics' permission. */
    gameModelFunctionCircuits: GmFunctionBreakerStatus;
    /** List studio-defined functions for an app, optionally filtered to those attached to a container type. Requires app-admin ('manage_apps'). */
    gameModelFunctions: Array<GmFunction>;
    /** Read the app's game-model runtime policy (session creation policy + default participant role). Requires app-admin ('manage_apps'). */
    gameModelPolicy: GmAppPolicy;
    /** List the property definitions for a container type. Requires app-admin ('manage_apps'). */
    gameModelPropertyDefs: Array<GmPropertyDef>;
    /** Fetch one session by id. Requires a valid token. */
    gameModelSession: GmSession;
    /** List sessions in an app, optionally filtered by status. Requires a valid token. */
    gameModelSessions: Array<GmSession>;
    /** List tier -> feature grants for an app, optionally filtered to one tier. Requires app-admin ('manage_apps'). */
    gameModelTierFeatures: Array<GmTierFeature>;
    /** Pending one-shot timers for the app, soonest first. A timer leaves this list the moment it is claimed for execution, so an empty list means nothing is scheduled (not that nothing ran). Requires app-admin ('manage_apps'). */
    gameModelTimers: Array<GmTimer>;
    /** Traverse the container graph from a root container along a relationship type up to a depth, returning the reachable nodes and edges. Requires a valid token. */
    gameModelTraverse: GmTraverseResult;
    /** Fetch a container type's full schema: its property definitions plus the functions available on it. Requires app-admin ('manage_apps'). */
    gameModelTypeSchema: GmTypeSchema;
    /** Fetches one chunk (its base64 voxel grid, per-voxel states, chunk state and LODs) by app id and chunk coordinates. Returns null if the chunk does not exist. Use the input's LOD options to limit which LODs come back. Requires a valid bearer token in the Authorization header; a token scoped to an app may only read that app's chunks. Read-only (no world state is changed). */
    getChunk: Maybe<Chunk>;
    /** Fetches only the requested level-of-detail (LOD) meshes for one chunk, identified by app id and coordinates. Returns null if the chunk does not exist. Cheaper than getChunk when you only need LODs. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    getChunkLods: Maybe<ChunkLodsResponse>;
    /** Returns all chunks for an app within a cubic (Chebyshev-distance) radius of a center chunk, paginated. The cube spans center +/- maxDistance chunks on each axis. Use this for bulk region loads; use getChunk for a single chunk. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    getChunksByDistance: ChunksByDistanceResponse;
    /** Returns all recorded voxel edits (the voxel_updates log) for a single chunk, newest first, as a ChunkVoxelResponse. Use getChunk instead when you want the packed voxel grid rather than the individual edit log. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    getVoxelList: ChunkVoxelResponse;
    /** List every registered GraphQL API server regardless of health/state. No authentication required. For service discovery; to route clients, prefer activeGraphQLServers (filters to healthy servers). */
    graphqlServers: Array<GraphQlServer>;
    /** The app's grid claim policy (D4): how a player claim confers grid ownership. */
    gridClaimPolicy: GridClaimPolicy;
    /** Pending grid claim requests: designated approvers (or studio staff holding manage_compute) see the app's queue; other callers see their own requests. */
    gridClaimRequests: Array<GridClaimRequest>;
    /** Marketplace and self-authored client mods attached to a grid. Rows include exact attachment consent plus an aggregate capability summary/hash and trust state per author. Games should show one author prompt, call trustGridAuthor, cache by clientArtifactHash, and poll this metadata to stop removed or changed workers. */
    gridClientMods: Array<GridClientMod>;
    /** List the group/role -> permission-key grants configured on a grid for one group (rows of the `grid_group_grants` input table). These are inputs to the effective ACL, not the materialized result — use `gridUserPermissions` for a specific user's effective keys. Requires app-admin ('manage_apps'). */
    gridGroupGrants: Array<GridGroupGrant>;
    /** Browse the app's grid listings (P4b): blueprints that stamp a fresh grid per purchase, or concrete grids. Buying confers ownership + keys + quota preset atomically. */
    gridListings: Array<GridListing>;
    /** Read the current first-class ownership record for a grid. Requires authentication. Returns null when the grid has no current/unexpired owner. Player server code always resolves its execution identity from this record. */
    gridOwnership: Maybe<GridOwnership>;
    /** Read the permission-key whitelist configured for a grid. An empty list means there is no limit (every active runtime permission may be granted on the grid). Requires app-admin ('manage_apps'). */
    gridPermissionLimits: GridPermissionLimits;
    /** Read one user's effective (materialized) runtime permission keys on a grid — the flattened union of direct and group-derived grants that Buddy enforces, with expired grants excluded. Use this to see what a user can actually do. To inspect the underlying inputs instead, use `gridGroupGrants` (group grants) and `gridPermissionLimits` (the whitelist). Requires app-admin ('manage_apps'). */
    gridUserPermissions: GridUserPermissions;
    /** Lists recorded voxel edits for all chunks within a cubic (Chebyshev) radius of a center chunk, grouped per chunk and ordered by increasing distance, paginated over chunks. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    listVoxelUpdatesByDistance: VoxelUpdatesByDistanceResponse;
    /** Lists recorded voxel edits for a single chunk (optionally only those at/after `since`), newest first. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    listVoxels: Array<Voxel>;
    /** Returns the authenticated user resolved from the token (sent as `Authorization: Bearer <token>`), or null if missing/invalid. Readable with either an identity session token or an app-scoped gameplay token. */
    me: Maybe<User>;
    /** Lists the roles assigned to a single org member. Requires a valid session token. */
    memberRoles: Array<OrgRole>;
    /** The authenticated caller's own access record for a given app, or null if they have none. Requires authentication. Use this to check whether the current user is entitled to the app and on which tier; inspect status to distinguish active vs revoked. */
    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. */
    myChannels: Array<GroupMembership>;
    /** Lists the authenticated caller's own checkouts (newest first), across every org and app. Use this for a self-service payment history; use `checkouts` for the cross-tenant super-admin view. Requires an authenticated user. */
    myCheckouts: CheckoutsPage;
    /** Lists the authenticated caller's own checkouts (newest first), across every org and app. Use this for a self-service payment history; use `checkoutsConnection` for the cross-tenant super-admin view. Requires an authenticated user. Relay cursor connection; prefer this over the offset-based myCheckouts. */
    myCheckoutsConnection: CheckoutsConnection;
    /**
     * Lifetime donation totals for the authenticated user, summed across every app. Requires a valid game token.
     * @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>;
    /** The caller's code entitlements in this app (all mode 'free' in P4a). Uninstalls never remove acquisitions. */
    myPlayerCodeAcquisitions: Array<PlayerCodeAcquisition>;
    /** The caller's active installs in this app: pinned versions, consent hashes, and target grids. */
    myPlayerCodeInstalls: Array<PlayerCodeInstall>;
    /**
     * The authenticated user’s property-token balances (available, in use, total). Requires a valid game token.
     * @deprecated Legacy donation/property-token data; these products are no longer purchasable. Retained for historical records.
     */
    myPropertyTokens: UserPropertyTokenData;
    /** The calling player's seller payout balance (pending/payable/reserved). */
    mySellerPayoutBalance: SellerPayoutBalance;
    /** The caller's teams in an app, with their roles and effective team permissions. Use this to discover which teams the current user belongs to and what they may do in each. */
    myTeams: Array<GroupMembership>;
    /** List every grid overlapping a chunk-coordinate bounding box, each with the given user's effective permission keys on it. Useful for previewing what a user can do across a region (e.g. around their current position). Requires app-admin ('manage_apps'). */
    nearbyGridPermissions: Array<NearbyGridPermissions>;
    /** An org's off-session auto-billing configuration (enabled flag, recharge amount, low-water threshold, per-period cap, and last error). Requires the 'view_billing' org permission. */
    orgAutoBilling: OrgAutoBilling;
    /** An org's free shared-app slot quota and how much of it is used. Apps beyond the quota still publish; metered usage is billed from the org wallet. Caller must be a member of the org. */
    orgFreeAppQuota: FreeAppQuota;
    /** Lists the members of an organization. Requires the 'manage_members' permission on the org (super admins bypass). */
    orgMembers: Array<OrgMember>;
    /** Lists the org's saved (vaulted) off-session payment methods. Returns metadata only (brand/last4/status), never card numbers. Requires the 'view_billing' org permission. */
    orgPaymentMethods: Array<SavedPaymentMethod>;
    /** The full seed list of permission keys. Used by the UI to render role editors. */
    orgPermissions: Array<OrgPermission>;
    /** Lists all roles defined in an organization. Requires the 'manage_members' permission on the org (super admins bypass). */
    orgRoles: Array<OrgRole>;
    /** Lists an organization's API tokens (metadata only; secret values are never returned here). Requires the 'manage_tokens' permission on the org (super admins bypass). */
    orgTokens: Array<OrgToken>;
    /** 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). */
    organizationBySlug: Maybe<Organization>;
    /** 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. */
    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;
    /** The datacenters this deployment can create an app in. Call this before createApp and use a returned `code` as input.datacenter: the argument is REQUIRED and permanent, because an app is distributed on its app_id and all of its data lives in one datacenter for the life of the app. Requires authentication. Offer only entries with placeable=true; an empty list means no datacenter topology has been pushed here and app creation will refuse until it has. Cheap and stable — the answer changes only when the fleet does, and it is served from Citus reference tables on whichever instance answers. */
    placeableDatacenters: PlaceableDatacenters;
    /** 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;
    /** The caller's player-wallet auto-recharge settings (off-session card top-up before the player gate denies for funds). */
    playerAutoBilling: PlayerAutoBilling;
    /** List only the caller-owned player automations in one currently owned grid. Requires an app-scoped token; no app-wide listing exists. */
    playerAutomations: Array<PlayerAutomation>;
    /** Fetch client WASM for an entitled marketplace install or an exact marketplace/self-authored grid attachment. Attachment fetches require current in-grid presence plus matching attachment consent or capability-bound author trust; self-authored code uses module/author admission rather than a synthetic listing. Every factor, including run_client_code, Buddy lease when enabled, and kill switches, fails closed as 'not found'. */
    playerCodeClientArtifact: PlayerClientArtifact;
    /** List the immutable published versions of a listing, newest first, with each version’s derived capability summary and consent hash. */
    playerCodeListingVersions: Array<PlayerCodeListingVersion>;
    /** Browse an app's active marketplace code listings (free mode). Each listing carries its admission standing: in allow_list apps a PENDING listing can be acquired but not installed. Closed-source listings expose artifact hashes and the derived capability summary only — never source. */
    playerCodeListings: Array<PlayerCodeListing>;
    /** Fetch a compiled CLIENT player artifact plus the metadata the browser broker needs to run it (player compute P3). Fail-closed: the caller must currently own the grid, be the version's author, hold run_client_code at app and grid scope, and the code must be admitted under the app's mode. Returns the gas-injected wasm bytes (base64), the declared client contract, and the per-dispatch fuel budget the glue worker enforces. Acquired (bought/rented) client code is served through the marketplace path in a later phase. */
    playerComputeArtifact: PlayerClientArtifact;
    /** Failed-run diagnostics for player modules on a grid the caller currently owns: the failing runs with their typed error kinds, newest first. The owner-scoped twin of computeModuleLogs. */
    playerComputeLogs: Array<PlayerWasmModuleRun>;
    /** List player modules the caller authored or that are installed on grids they currently own. Requires a valid app token; closed source is never included here. */
    playerComputeMyModules: Array<PlayerWasmModule>;
    /** List executions of player modules on a grid the caller currently owns, newest first. Every run is attributed to the grid owner it executed as; author identity never appears here. */
    playerComputeRuns: Array<PlayerWasmModuleRun>;
    /** Active player-compute kill switches for an app, newest first. Requires the org 'view_compute_diagnostics' permission. */
    playerComputeSwitches: Array<PlayerComputeSwitch>;
    /** The caller's player-compute spend and quota view for one app (P2): compute units used in the current clock hour/day vs the effective units_per_hour/units_per_day policy caps, compile-quota utilization, and the wallet/spend-cap gate state with its typed reason. This is the remaining-budget source the live-coding panel consumes. */
    playerComputeUsage: PlayerComputeUsage;
    /** List immutable versions for one player module. Source and compile logs are returned only to the personal author, or source when that version is open-source. There is intentionally no studio/operator moderation override. */
    playerComputeVersions: Array<PlayerWasmModuleVersion>;
    /** Return one caller-owned player-model container in the specified app/grid, or null when it is absent or outside that owner scope. Requires current grid ownership. */
    playerModelContainer: Maybe<PlayerModelContainer>;
    /** List flexible player-model containers owned by the caller in one currently owned grid. Requires an app-scoped token and current grid ownership; never returns app-wide or foreign-owner rows. */
    playerModelContainers: Array<PlayerModelContainer>;
    /** 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;
    /** The app's player rate-card markup in basis points on the platform base price (06 §4): the studio's usage-revenue stream, shown to players as a separate spend-history component. 0 = no markup (the BWF posture). Requires 'view_billing'. */
    playerRateMarkup: Scalars['Int']['output'];
    /** The caller's per-app player runtime gate states. Only apps where the gate has ever acted appear; absence means active. 'denied' with PLAYER_WALLET_EMPTY or PLAYER_SPEND_CAP pauses that player's grid compute only — play is never touched. */
    playerRuntimeStates: Array<PlayerRuntimeState>;
    /** The caller's self-set spend caps (global and per-app) with running counters. The effective runtime limit is min(developer policy, self-cap, wallet balance). */
    playerSpendCaps: Array<PlayerSpendCap>;
    /** The caller's posted hourly player-usage charges, newest first, optionally filtered by app. Each charge splits platformCents (base rate card) from markupCents (the studio's configured markup) with a per-metric snapshot — players always see what the platform charges and what the studio adds. */
    playerUsageCharges: Array<PlayerUsageCharge>;
    /** The caller's player wallet, created empty on first access (never null). Platform-scoped: one wallet funds the player's grid compute across every org/app (DN-5); org billing never touches it. Fund it via createCheckout purpose PLAYER_WALLET_TOPUP. */
    playerWalletBalance: PlayerWallet;
    /** The caller's player-wallet ledger, newest first: top-ups, hourly usage debits (per app), auto-recharges, refunds, and adjustments. Usage-debit hours are broken down by playerUsageCharges, whose snapshot splits the platform and studio-markup components. */
    playerWalletTransactions: Array<PlayerWalletTransaction>;
    /** List an app's player-compute policy rows (developer cost/rate clamps per player or cohort, 06 §3), most general first. Requires 'view_compute_diagnostics'. Management is authoritative; rows replica-sync to the game runtime on change. */
    playerWasmPolicies: Array<PlayerWasmPolicy>;
    /** 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;
    /** 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. */
    quotasForApp: Array<ServiceQuota>;
    /** Lists the org-scoped quota rules explicitly configured for an organization (excludes app-, tier-, and free-tier-default quotas). Use `effectiveQuota` to resolve the limit actually applied for a given metric. Requires the 'view_usage' org permission. */
    quotasForOrg: Array<ServiceQuota>;
    /** Lists all valid runtime permission keys (e.g. "access", "teleport", "update_voxel_data", "use_voice_chat") that may be assigned to an access tier permissionKeys. PUBLIC: no authentication required. Ordered by the permission bit index. */
    runtimePermissions: Array<Scalars['String']['output']>;
    /** Pick a low-load game server for a native (direct-UDP) client to connect to: returns a random server from the least-loaded ~20% (by client count) of ReadyForClients servers to spread load, always CO-LOCATED with the datacenter that holds the data for this app (all rows for one app live in a single datacenter). This REFUSES rather than returning a Buddy elsewhere, because every gameplay write for the session would otherwise cross datacenters — invisible, because each write still succeeds — and the refusal tells you which of three situations you are in. If you reached the wrong datacenter (the shared entry name resolves to all of them, so this is the common case for a client that has not re-discovered) it is WRONG_DATACENTER, carrying gameApiUrl and gameApiWsUrl in extensions: reconnect there and retry, which the CrowdyJS and CrowdyCPP clients do for you. If the app’s own datacenter is not serving at all it is APP_UNAVAILABLE, deliberately with no endpoint. Only when this IS the app’s datacenter and it has no healthy co-located Buddy is it NO_LOCAL_BUDDY — also with no endpoint, because there is nowhere else to go; that one needs an operator. Requires a bearer game token; as a side effect it authorizes that token’s P2P session with the chosen Buddy so the native client’s spatial datagrams are accepted. Connect the native client to the returned ip4 and clientPort. Browser clients should instead use the UDP proxy (connectUdpProxy / udpNotifications) and do not need this. */
    serverWithLeastClients: ServerStatus;
    /** @deprecated Legacy monthly app-slot subscription catalog. New shared publishes use wallet usage billing only. */
    sharedEnvPlans: Array<SharedEnvPlan>;
    /** Fetch one team by id. Errors if the id is not a team. */
    team: Group;
    /** List the members of a team (including pending requests, each with their status and roles). */
    teamMembers: Array<GroupMember>;
    /** The current team creation/membership policy for an app (who may create teams and the default membership policy of new teams). Falls back to app defaults when unset. */
    teamPolicy: AppGroupPolicy;
    /** List the roles of a team, including the system 'leader' role and the group-management permission keys each role grants. */
    teamRoles: Array<GroupRole>;
    /** List all active teams in an app (not just the caller's). */
    teams: Array<Group>;
    /** UDP proxy session status for the game token on this request. Without a game token, returns connected: false. Does not open a session—use udpNotifications or connectUdpProxy. */
    udpProxyConnectionStatus: UdpProxyConnectionStatus;
    /** Looks up a single user by id. Requires a valid game token. */
    user: Maybe<User>;
    /** Reads the authenticated user’s per-app state for `appId` (keyed by appId+userId). Requires a valid game token; only the caller’s own state is returned. Returns null when no row exists. `state` is base64-encoded binary. */
    userAppState: Maybe<UserAppState>;
    /** Lists all per-app state rows for the authenticated user, ordered newest-updated first. Requires a valid game token; only the caller’s own states are returned. `state` blobs are base64-encoded binary. */
    userAppStates: Array<UserAppState>;
    /** Lists the avatars owned by `userId`. Requires a valid game token. Owner-aware: when the caller is NOT the owner, each avatar’s `privateState` is stripped (returned null); `publicState` is always included. State blobs are base64-encoded binary. */
    userAvatars: Array<Avatar>;
    /** Faults grouped by engine, kind, blame and subject over a window, most frequent first. This is the health question: a count per shape answers 'what is failing and how often', which a single overwritten last_error slot never could — five prod modules read last_error = NULL while holding 4,767 lifetime watchdog terminations between them. Requires the org 'view_compute_diagnostics' permission. */
    userCodeFaultSummary: Array<UserCodeFaultSummaryEntry>;
    /** Failures of code this app's users wrote, newest first, across all three engines (model expressions, studio WASM, player WASM). Each row carries what ran, what went wrong, whose problem it is, whether retrying could help, and what the run cost against what it was allowed. Requires the org 'view_compute_diagnostics' permission. */
    userCodeFaults: Array<UserCodeFaultRecord>;
    /** Super admin only. Paginated user search across email, gamertag, disambiguation, and exact user_id. Relay cursor connection; prefer this over the offset-based usersPaginated. */
    usersConnection: UsersConnection;
    /** SUPER-ADMIN ONLY paginated user search; replaces the legacy `users`/`usersByGamertag`/`usersByEmail` queries. `query` is ILIKE-prefix matched against email, gamertag, and disambiguation, plus an exact user_id match. Requires a super-admin bearer game token. */
    usersPaginated: UsersPage;
    /** Current server version and the minimum client version the server accepts. No authentication required. Compare your client build against minimumClientVersion before connecting and prompt an update if it is too old. */
    versionInfo: ServerVersionInfo;
    /** Returns entries from the immutable voxel edit history (voxel_updates_history) for an app, newest first, optionally filtered by user id and a changed-at time window. Returns up to `limit` entries (DEFAULT 500, max 50000) starting at `offset`. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    voxelUpdateHistory: Array<VoxelUpdateHistoryEvent>;
    /** Relay-style cursor-paginated version of `voxelUpdateHistory`: returns entries from the immutable voxel edit history (voxel_updates_history) for an app, newest first, optionally filtered by user id and a changed-at time window. Page forward with `first` (default 50, max 200) and `after` (an opaque cursor from a previous page’s `pageInfo.endCursor`); the legacy `limit`/`offset` args are ignored on this query. Requires a valid bearer token; app-scoped tokens are limited to their own app. Read-only. */
    voxelUpdateHistoryConnection: VoxelUpdateHistoryConnection;
    /** Returns the organization's wallet, creating an empty zero-balance wallet on first access if one does not yet exist (so it never returns null). Use it to read the current balance and currency before charging usage or topping up. Requires the 'view_billing' org permission. */
    walletBalance: OrgWallet;
    /** Lists the organization's wallet transactions (credits and debits), ordered newest first. Use it to audit how the balance changed over time. Requires the 'view_billing' org permission. */
    walletTransactions: Array<WalletTransaction>;
    /** Lists the organization's wallet transactions (credits and debits), ordered newest first. Use it to audit how the balance changed over time. Requires the 'view_billing' org permission. Relay cursor connection; prefer this over the offset-based walletTransactions. */
    walletTransactionsConnection: WalletTransactionsConnection;
};
export type QueryActorArgs = {
    uuid: Scalars['String']['input'];
};
export type QueryActorsArgs = {
    filter?: InputMaybe<ActorFilterInput>;
};
export type QueryActorsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<ActorFilterInput>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryAmIGameHostArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppAccessTiersArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppBudgetArgs = {
    appId: Scalars['BigInt']['input'];
    orgId: Scalars['BigInt']['input'];
};
export type QueryAppBudgetsArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryAppBySlugArgs = {
    appSlug: Scalars['String']['input'];
    orgSlug: Scalars['String']['input'];
};
export type QueryAppCodeAdmissionModeArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppCodeAdmissionQueueArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppCodeAdmissionsArgs = {
    appId: Scalars['BigInt']['input'];
    includeRevoked?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryAppComputeBudgetArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppComputeBudgetStatusArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppComputeUsageArgs = {
    appId: Scalars['BigInt']['input'];
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryAppDiscoveryArgs = {
    appIds: Array<Scalars['BigInt']['input']>;
};
export type QueryAppGrantMemberCandidatesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppGraphqlOperationsArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    orgId: Scalars['BigInt']['input'];
    since: Scalars['DateTime']['input'];
};
export type QueryAppPlayerCodeAcquisitionsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppPlayerCodeListingVersionsArgs = {
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
};
export type QueryAppPlayerCodeListingsArgs = {
    appId: Scalars['BigInt']['input'];
    includeDelisted?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryAppPlayerMarkupAccruedArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryAppPlayerUsageArgs = {
    appId: Scalars['BigInt']['input'];
    hours?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryAppRuntimeStateArgs = {
    appId: Scalars['BigInt']['input'];
};
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']>;
    orgId: Scalars['BigInt']['input'];
    since: Scalars['DateTime']['input'];
};
export type QueryAppUserAccessByAppArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    status?: InputMaybe<Scalars['String']['input']>;
};
export type QueryAppUserAccessConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    appId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
    status?: InputMaybe<Scalars['String']['input']>;
};
export type QueryAppsArgs = {
    filter?: InputMaybe<AppMarketplaceFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryAppsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<AppMarketplaceFilterInput>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryAppsForOrgArgs = {
    orgSlug: Scalars['String']['input'];
};
export type QueryAvatarArgs = {
    id: Scalars['BigInt']['input'];
};
export type QueryAvatarAppStateArgs = {
    appId: Scalars['BigInt']['input'];
    avatarId: Scalars['BigInt']['input'];
};
export type QueryAvatarAppStatesArgs = {
    appId: Scalars['BigInt']['input'];
    avatarIds: Array<Scalars['BigInt']['input']>;
};
export type QueryBatchLookupActorsArgs = {
    input: BatchActorLookupInput;
};
export type QueryBillingRateCardArgs = {
    scope: RateScope;
};
export type QueryChannelArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type QueryChannelMembersArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type QueryChannelPolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryChannelRolesArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type QueryChannelsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryCheckAuthMethodArgs = {
    input: CheckAuthMethodInput;
};
export type QueryCheckoutsArgs = {
    filter?: InputMaybe<CheckoutFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryCheckoutsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<CheckoutFilterInput>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryCommerceRiskQueueArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryComputeAppDiagnosticsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryComputeModuleArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type QueryComputeModuleLogsArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    moduleName?: InputMaybe<Scalars['String']['input']>;
};
export type QueryComputeModulePolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryComputeModuleRunsArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    moduleName?: InputMaybe<Scalars['String']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryComputeModuleStatsArgs = {
    appId: Scalars['BigInt']['input'];
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryComputeModuleTriggersArgs = {
    appId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
};
export type QueryComputeModuleVersionsArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    moduleName: Scalars['String']['input'];
};
export type QueryComputeModulesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryComputeTemplatesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryCrowdyStudioAgentBudgetArgs = {
    sessionId: Scalars['String']['input'];
};
export type QueryCrowdyStudioAgentEffectivePolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryCrowdyStudioAgentHistoryArgs = {
    afterSeq?: InputMaybe<Scalars['BigInt']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    sessionId: Scalars['String']['input'];
};
export type QueryCrowdyStudioAgentPolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryCrowdyStudioAgentSessionArgs = {
    sessionId: Scalars['String']['input'];
};
export type QueryCrowdyStudioAgentSessionsArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    appId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryCrowdyStudioAgentToolDescriptorsArgs = {
    sessionId: Scalars['String']['input'];
};
export type QueryCrowdyStudioAgentUsageArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    since?: InputMaybe<Scalars['DateTime']['input']>;
    until?: InputMaybe<Scalars['DateTime']['input']>;
};
export type QueryCrowdyStudioCommonFilesArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    target?: InputMaybe<CrowdyStudioTarget>;
};
export type QueryCrowdyStudioLibraryFilesArgs = {
    appId: Scalars['BigInt']['input'];
    includeArchived?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryCrowdyStudioProjectArgs = {
    appId: Scalars['BigInt']['input'];
    projectId: Scalars['String']['input'];
};
export type QueryCrowdyStudioProjectsArgs = {
    appId: Scalars['BigInt']['input'];
    includeArchived?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryEffectiveQuotaArgs = {
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    metric: Scalars['String']['input'];
    orgId?: InputMaybe<Scalars['BigInt']['input']>;
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
};
export type QueryEmailDeliverabilityArgs = {
    email: Scalars['String']['input'];
    eventLimit?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryGameClientBootstrapArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameHostArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelActivePlayerCountArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelAppDiagnosticsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelAutomationArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type QueryGameModelAutomationPolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelAutomationRunsArgs = {
    appId: Scalars['BigInt']['input'];
    automationName?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryGameModelAutomationStatsArgs = {
    appId: Scalars['BigInt']['input'];
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryGameModelAutomationTriggersArgs = {
    appId: Scalars['BigInt']['input'];
    automationName?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGameModelAutomationsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelContainerArgs = {
    appId: Scalars['BigInt']['input'];
    containerId: Scalars['String']['input'];
};
export type QueryGameModelContainerStateArgs = {
    appId: Scalars['BigInt']['input'];
    containerId: Scalars['String']['input'];
};
export type QueryGameModelContainerTypesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelContainersArgs = {
    appId: Scalars['BigInt']['input'];
    bindingKey?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
    typeName?: InputMaybe<Scalars['String']['input']>;
    where?: InputMaybe<Array<GmPropertyPredicateInput>>;
};
export type QueryGameModelEventsArgs = {
    appId: Scalars['BigInt']['input'];
    functionName?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    selfContainerId?: InputMaybe<Scalars['String']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryGameModelEventsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    appId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
    functionName?: InputMaybe<Scalars['String']['input']>;
    selfContainerId?: InputMaybe<Scalars['String']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryGameModelFeaturesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelFlowArgs = {
    appId: Scalars['BigInt']['input'];
    flowId: Scalars['String']['input'];
};
export type QueryGameModelFunctionArgs = {
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type QueryGameModelFunctionCircuitsArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGameModelFunctionsArgs = {
    appId: Scalars['BigInt']['input'];
    containerTypeName?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGameModelPolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGameModelPropertyDefsArgs = {
    appId: Scalars['BigInt']['input'];
    typeName: Scalars['String']['input'];
};
export type QueryGameModelSessionArgs = {
    appId: Scalars['BigInt']['input'];
    sessionId: Scalars['String']['input'];
};
export type QueryGameModelSessionsArgs = {
    appId: Scalars['BigInt']['input'];
    status?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGameModelTierFeaturesArgs = {
    appId: Scalars['BigInt']['input'];
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
};
export type QueryGameModelTimersArgs = {
    appId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGameModelTraverseArgs = {
    appId: Scalars['BigInt']['input'];
    depth?: InputMaybe<Scalars['Int']['input']>;
    relationshipType: Scalars['String']['input'];
    rootId: Scalars['String']['input'];
};
export type QueryGameModelTypeSchemaArgs = {
    appId: Scalars['BigInt']['input'];
    typeName: Scalars['String']['input'];
};
export type QueryGetChunkArgs = {
    input: GetChunkInput;
};
export type QueryGetChunkLodsArgs = {
    input: GetChunkLodsInput;
};
export type QueryGetChunksByDistanceArgs = {
    input: GetChunksByDistanceInput;
};
export type QueryGetVoxelListArgs = {
    input: GetVoxelListInput;
};
export type QueryGridClaimPolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGridClaimRequestsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGridClientModsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type QueryGridGroupGrantsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    groupId: Scalars['BigInt']['input'];
};
export type QueryGridListingsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryGridOwnershipArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type QueryGridPermissionLimitsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type QueryGridUserPermissionsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
};
export type QueryListVoxelUpdatesByDistanceArgs = {
    input: ListVoxelUpdatesByDistanceInput;
};
export type QueryListVoxelsArgs = {
    input: ListVoxelsInput;
};
export type QueryMemberRolesArgs = {
    orgMemberId: Scalars['BigInt']['input'];
};
export type QueryMyAppAccessArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryMyChannelsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryMyCheckoutsArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryMyCheckoutsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryMyPlayerCodeAcquisitionsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryMyPlayerCodeInstallsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryMyTeamsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryNearbyGridPermissionsArgs = {
    input: NearbyGridPermissionsInput;
};
export type QueryOrgAutoBillingArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryOrgFreeAppQuotaArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryOrgMembersArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryOrgPaymentMethodsArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryOrgRolesArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryOrgTokensArgs = {
    orgId: Scalars['BigInt']['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'];
};
export type QueryOrganizationBySlugArgs = {
    slug: Scalars['String']['input'];
};
export type QueryPaymentEventsArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryPaymentEventsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryPlayerAutomationsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type QueryPlayerCodeClientArtifactArgs = {
    appId: Scalars['BigInt']['input'];
    attachmentId?: InputMaybe<Scalars['String']['input']>;
    listingId?: InputMaybe<Scalars['String']['input']>;
    versionId?: InputMaybe<Scalars['String']['input']>;
};
export type QueryPlayerCodeListingVersionsArgs = {
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
};
export type QueryPlayerCodeListingsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryPlayerComputeArtifactArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    versionId?: InputMaybe<Scalars['String']['input']>;
};
export type QueryPlayerComputeLogsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    moduleName?: InputMaybe<Scalars['String']['input']>;
};
export type QueryPlayerComputeMyModulesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryPlayerComputeRunsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    moduleName?: InputMaybe<Scalars['String']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
};
export type QueryPlayerComputeSwitchesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryPlayerComputeUsageArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryPlayerComputeVersionsArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
};
export type QueryPlayerModelContainerArgs = {
    input: PlayerModelContainerRefInput;
};
export type QueryPlayerModelContainersArgs = {
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
};
export type QueryPlayerPulseArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryPlayerRateMarkupArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryPlayerUsageChargesArgs = {
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryPlayerWalletTransactionsArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryPlayerWasmPoliciesArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryPortalConsentArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryQuotasForAppArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryQuotasForOrgArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryTeamArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type QueryTeamMembersArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type QueryTeamPolicyArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryTeamRolesArgs = {
    groupId: Scalars['BigInt']['input'];
};
export type QueryTeamsArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryUserArgs = {
    id: Scalars['BigInt']['input'];
};
export type QueryUserAppStateArgs = {
    appId: Scalars['BigInt']['input'];
};
export type QueryUserAvatarsArgs = {
    userId: Scalars['BigInt']['input'];
};
export type QueryUserCodeFaultSummaryArgs = {
    appId: Scalars['BigInt']['input'];
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryUserCodeFaultsArgs = {
    appId: Scalars['BigInt']['input'];
    blame?: InputMaybe<UserCodeFaultBlame>;
    engine?: InputMaybe<UserCodeFaultEngine>;
    kind?: InputMaybe<UserCodeFaultKind>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    subject?: InputMaybe<Scalars['String']['input']>;
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
};
export type QueryUsersConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    query?: InputMaybe<Scalars['String']['input']>;
};
export type QueryUsersPaginatedArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    query?: InputMaybe<Scalars['String']['input']>;
};
export type QueryVoxelUpdateHistoryArgs = {
    appId: Scalars['BigInt']['input'];
    from?: InputMaybe<Scalars['DateTime']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    to?: InputMaybe<Scalars['DateTime']['input']>;
    userId?: InputMaybe<Scalars['BigInt']['input']>;
};
export type QueryVoxelUpdateHistoryConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    appId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
    from?: InputMaybe<Scalars['DateTime']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    to?: InputMaybe<Scalars['DateTime']['input']>;
    userId?: InputMaybe<Scalars['BigInt']['input']>;
};
export type QueryWalletBalanceArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type QueryWalletTransactionsArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orgId: Scalars['BigInt']['input'];
};
export type QueryWalletTransactionsConnectionArgs = {
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    orgId: Scalars['BigInt']['input'];
};
/** One priced dimension: its rate and, where it has one, its hourly free allowance. A dimension with a price of 0 is metered but not charged. */
export type RateCardEntryType = {
    __typename?: 'RateCardEntryType';
    /** ISO currency code. USD today. */
    currency: Scalars['String']['output'];
    /** Operator note on the seed row; null when unset. */
    description: Maybe<Scalars['String']['output']>;
    /** Raw metric units free per clock hour before anything is charged, as a BigInt decimal string. Null when this dimension has no allowance row, which for a priced dimension means it bills from the first unit. */
    freePerHour: Maybe<Scalars['BigInt']['output']>;
    /** Raw metric units free per UTC calendar month, as a BigInt decimal string. On the PLAYER card this is the pooled monthly trial budget per (player, app), and player_wasm_compute_units is its canonical key. Null when this dimension has no monthly allowance. */
    freePerMonth: Maybe<Scalars['BigInt']['output']>;
    /** The metered dimension, e.g. "graphql_recv_ops" or "player_wasm_compute_units". Matches a key the billing tick aggregates. */
    metric: Scalars['String']['output'];
    /** Cents charged per unitQuantity raw units, above the free allowance. Fractional values are permitted (the column is NUMERIC(20,6)). 0 means metered but not charged. */
    priceCents: Scalars['Float']['output'];
    /** Which card this row is on. */
    scope: RateScope;
    /** Human unit this price is quoted in, e.g. "GiB" or "M units". Display only; the arithmetic uses unitQuantity. */
    unitLabel: Scalars['String']['output'];
    /** How many raw metric units one priceCents charge covers, as a BigInt decimal string. A price of 15 with unitQuantity 1073741824 is 15 cents per GiB. */
    unitQuantity: Scalars['BigInt']['output'];
};
/** One field that moved, with the value it held before. Reported so a price change is auditable from the response rather than reconstructed afterwards. */
export type RateChangeType = {
    __typename?: 'RateChangeType';
    /** One of "priceCents", "unitLabel", "unitQuantity", "freePerHour" or "freePerMonth". */
    field: Scalars['String']['output'];
    metric: Scalars['String']['output'];
    /** The value before this call, as a decimal string. "none" when there was no allowance row. */
    previous: Scalars['String']['output'];
    scope: RateScope;
    /** The value after this call, as a decimal string. */
    updated: Scalars['String']['output'];
};
/** Which rate card. SHARED prices organization metered usage for shared-environment apps (billed hourly to the org wallet as "shared_usage"). PLAYER prices player compute (billed hourly to the player wallet as "usage_debit"). */
export declare enum RateScope {
    Player = "PLAYER",
    Shared = "SHARED"
}
/** Realtime lifecycle event delivered on the udpNotifications subscription. It is a control frame — it carries no appId, so it is never dropped by the per-app fan-out filter. Branch on `code`; use `retryable` to decide whether retrying can succeed. Most codes report that a session could not be opened or correctly scoped and are TERMINAL: the subscription completes immediately after emitting one, so the client must fix the cause and resubscribe. The exception is SERVER_DRAINING, which arrives mid-stream on a healthy subscription and does NOT end it — see that code below. */
export type RealtimeConnectionEvent = {
    __typename?: 'RealtimeConnectionEvent';
    /** Machine-readable failure reason. Branch on this (not on `message`). Known values: AUTH_REQUIRED — no valid bearer game token was presented on the WS connection_init / request; authenticate via the Management API and resubscribe (not retryable as-is). APP_ID_REQUIRED — the subscription was opened without an appId scope; udpNotifications must be app-scoped (game tokens are app-agnostic and one socket is shared across apps), so pass the app you are playing and resubscribe (not retryable as-is). UDP_PROXY_CONNECTION_FAILED — the proxy could not open or keep a UDP socket to the selected game server (transient/infrastructure); back off and resubscribe (retryable). `message` carries the specific underlying detail for this case. SERVER_DRAINING — this API instance is being taken out of service; the stream KEEPS WORKING, but you should re-run discovery (mintAppToken) and reconnect to the instance it returns before this one stops. Only reaches clients connected directly to an instance; clients behind the load balancer are moved for them. */
    code: Scalars['String']['output'];
    /** Human-readable explanation of the failure, suitable for logs and developer-facing surfaces. Do not parse or branch on this text — branch on `code` instead. */
    message: Scalars['String']['output'];
    /** Whether resubscribing without changing anything may succeed. true for transient failures (e.g. UDP_PROXY_CONNECTION_FAILED) — back off and retry. false for caller errors that must be fixed first (AUTH_REQUIRED needs a fresh/valid game token; APP_ID_REQUIRED needs an appId-scoped subscription). */
    retryable: Scalars['Boolean']['output'];
    /** Lifecycle status: "failed" when the session could not be established or had to be torn down, or "draining" for the one advisory case (SERVER_DRAINING) where the stream stays open. */
    status: Scalars['String']['output'];
};
export type RegisterUserInput = {
    /** Email for the new account; the confirmation email is sent here. */
    email: Scalars['String']['input'];
    /** Optional initial public gamertag (min 3 characters). Can be set later via updateGamertag. */
    gamertag?: InputMaybe<Scalars['String']['input']>;
    /** Password for the new account (min 8 characters). */
    password: Scalars['String']['input'];
};
/** Result of releasing a grid created by the caller through claimGridChunk. The ownership, direct/effective ACL, and grid have been removed atomically, making its chunk claimable again. */
export type ReleaseClaimedGridResult = {
    __typename?: 'ReleaseClaimedGridResult';
    /** Id of the self-claimed grid that was removed. */
    gridId: Scalars['BigInt']['output'];
    /** High corner of the removed one-chunk grid. */
    highChunk: ChunkCoordinates;
    /** Low corner of the removed one-chunk grid. */
    lowChunk: ChunkCoordinates;
    /** Claim policy under which the removed grid was created. */
    policy: GridClaimPolicy;
    /** True after the ownership, ACL rows, and grid were removed in one committed transaction. */
    released: Scalars['Boolean']['output'];
};
/** 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';
    /** 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'];
    /** Password-reset token from the emailed reset link. */
    token: Scalars['String']['input'];
};
/** Immediately revoke one visible lease. */
export type RevokeAgentLeaseInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Lease UUID to revoke. */
    leaseId: Scalars['String']['input'];
    /** Optional strict CrowdyJS/BWF preemption reason; defaults to HUMAN_STOP. */
    reason?: InputMaybe<CrowdyStudioAgentPreemptionReason>;
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
};
/** Revoke a user's direct grants on a grid (deletes from the grid_user_direct_grants input table). */
export type RevokeGridPermissionsInput = {
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['input'];
    /** The grid to revoke on. */
    gridId: Scalars['BigInt']['input'];
    /** Optional idempotency key. Recommended for retries: replaying with the same key and identical input returns the first result instead of re-applying; the same key with different input returns IDEMPOTENCY_CONFLICT. Keys expire after 24h. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Optional subset of permission key strings to revoke. Omit to revoke ALL of the user's direct grants on this grid. Each key must be a known runtime permission key, unique, and at most 64 chars. */
    permissionKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    /** The user whose direct grants to revoke. */
    userId: Scalars['BigInt']['input'];
};
/** Revoke a group's (optionally one role's) grants on a grid (deletes from the grid_group_grants input table). */
export type RevokeGroupFromGridInput = {
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['input'];
    /** The grid to revoke on. */
    gridId: Scalars['BigInt']['input'];
    /** The group whose grants to revoke. */
    groupId: Scalars['BigInt']['input'];
    /** Optional role to target. Must match the role the grant was created with (omit to target the group-wide grant, i.e. the grant with no role). */
    groupRoleId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Optional subset of keys to revoke. Omit to revoke all of the group/role grants on this grid. */
    permissionKeys?: InputMaybe<Array<Scalars['String']['input']>>;
};
/** Per-voxel outcome of a rollbackVoxelUpdates call. In dry-run mode this describes what WOULD happen; otherwise it reports what was applied. One result is returned per affected voxel. */
export type RollbackVoxelEventResult = {
    __typename?: 'RollbackVoxelEventResult';
    /** Id of the app this result belongs to (decimal string). */
    appId: Scalars['BigInt']['output'];
    /** True if the change was actually written; false in dry-run mode or when the voxel was skipped. */
    applied: Scalars['Boolean']['output'];
    /** Address of the chunk that contains the affected voxel. */
    coordinates: ChunkCoordinates;
    /** Voxel type immediately before the rollback (the current value), or null. */
    fromVoxelType: Maybe<Scalars['Int']['output']>;
    /** Local position of the affected voxel within its chunk. */
    location: VoxelCoordinates;
    /** The action computed for this voxel by the rollback (the revert operation to perform). */
    plannedAction: Scalars['String']['output'];
    /** Human-readable explanation when a voxel is skipped or an action is taken, or null. */
    reason: Maybe<Scalars['String']['output']>;
    /** Voxel type the voxel would be / was reverted to, or null. */
    toVoxelType: Maybe<Scalars['Int']['output']>;
};
/** Payload for rollbackVoxelUpdates: selects the voxel edits made by one user in one app within a time window to revert. */
export type RollbackVoxelUpdatesInput = {
    /** Id of the app whose voxels to roll back (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** When true (the DEFAULT), only computes and returns the planned reversions WITHOUT writing anything; set false to actually apply the rollback (DESTRUCTIVE — mutates world state). */
    dryRun?: Scalars['Boolean']['input'];
    /** Inclusive start of the time window of edits to revert. */
    from: Scalars['DateTime']['input'];
    /** Optional idempotency key. Recommended for retries: replaying with the same key and identical input returns the first result instead of re-applying; the same key with different input returns IDEMPOTENCY_CONFLICT. Keys expire after 24h. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Inclusive end of the time window of edits to revert. */
    to: Scalars['DateTime']['input'];
    /** Id of the user (decimal string) whose edits within the window will be reverted. */
    userId: Scalars['BigInt']['input'];
};
/** Create or optimistically update one private reusable personal-library file. */
export type SaveCrowdyStudioLibraryFileInput = {
    /** App tenant. Requires an app-scoped token; ownership is always the authenticated user. */
    appId: Scalars['BigInt']['input'];
    /** Private UTF-8 source text, capped at 64 KiB. */
    content: Scalars['String']['input'];
    /** Required current revision when libraryFileId is supplied; omit on create. */
    expectedRevision?: InputMaybe<Scalars['BigInt']['input']>;
    /** Optional 24-hour retry key. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Existing library UUID to update; omit to create a new entry. */
    libraryFileId?: InputMaybe<Scalars['String']['input']>;
    /** Safe suggested destination path: Cargo.toml or a .rs file below src/. */
    pathHint: Scalars['String']['input'];
    /** Optional unique lowercase discovery tags; at most 16, each at most 32 characters. */
    tags?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Compatible project target for this reusable file. */
    target: CrowdyStudioTarget;
    /** Player-facing library title. */
    title: Scalars['String']['input'];
};
/** Atomically upsert and delete a private project’s text files under one expected project revision. */
export type SaveCrowdyStudioProjectFilesInput = {
    /** App tenant that owns the private project. */
    appId: Scalars['BigInt']['input'];
    /** Files to remove in the same transaction. A target/path cannot also appear in upserts. */
    deletes?: InputMaybe<Array<CrowdyStudioProjectFileDeleteInput>>;
    /** Current project revision used for optimistic concurrency across the entire batch. */
    expectedRevision: Scalars['BigInt']['input'];
    /** Optional 24-hour retry key; recommended because a successful batch increments the expected revision. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Project UUID to mutate. */
    projectId: Scalars['String']['input'];
    /** Files to insert or replace. The batch commits only if all paths and post-save caps are valid. */
    upserts?: InputMaybe<Array<CrowdyStudioProjectFileInput>>;
};
/** Atomically save selected project metadata plus a batch of file upserts/deletes under one expected project revision. Crowdy Studio uses this to persist one coherent full-stack edit. */
export type SaveCrowdyStudioProjectInput = {
    /** New supported ABI pin, or omit to preserve. */
    abiVersion?: InputMaybe<Scalars['Int']['input']>;
    /** App tenant that owns the private project. */
    appId: Scalars['BigInt']['input'];
    /** New CLIENT module name, explicit null to clear, or omit to preserve. */
    clientModuleName?: InputMaybe<Scalars['String']['input']>;
    /** Files to delete in the same transaction. A target/path cannot also appear in upserts. */
    deletes?: InputMaybe<Array<CrowdyStudioProjectFileDeleteInput>>;
    /** New private description, explicit null to clear, or omit to preserve. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Current project revision. A stale value returns CONFLICT with CROWDY_STUDIO_REVISION_CONFLICT and applies no metadata or file writes. */
    expectedRevision: Scalars['BigInt']['input'];
    /** New optional grid affinity, explicit null to clear, or omit to preserve. Affinity never grants deploy authority. */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Optional 24-hour retry key; recommended because a successful atomic save increments the expected revision. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** New non-empty project name, or omit to preserve. */
    name?: InputMaybe<Scalars['String']['input']>;
    /** New editor pairing preference, or omit to preserve. */
    pairingPreference?: InputMaybe<CrowdyStudioPairingPreference>;
    /** Project UUID to update. */
    projectId: Scalars['String']['input'];
    /** New supported SDK pin, or omit to preserve. */
    sdkVersion?: InputMaybe<Scalars['String']['input']>;
    /** New SERVER module name, explicit null to clear, or omit to preserve. */
    serverModuleName?: InputMaybe<Scalars['String']['input']>;
    /** Changed or new files to insert/replace. Unmentioned files and their provenance remain unchanged. */
    upserts?: InputMaybe<Array<CrowdyStudioProjectFileInput>>;
};
/** Optimistically save selected project metadata. Omitted fields remain unchanged; explicit null clears nullable metadata. */
export type SaveCrowdyStudioProjectMetadataInput = {
    /** New supported ABI pin, or omit to preserve. */
    abiVersion?: InputMaybe<Scalars['Int']['input']>;
    /** App tenant that owns the private project. */
    appId: Scalars['BigInt']['input'];
    /** New CLIENT module name, explicit null to clear, or omit to preserve. */
    clientModuleName?: InputMaybe<Scalars['String']['input']>;
    /** New private description, explicit null to clear, or omit to preserve. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Current project revision. A stale value returns CONFLICT with CROWDY_STUDIO_REVISION_CONFLICT. */
    expectedRevision: Scalars['BigInt']['input'];
    /** New optional grid affinity, explicit null to clear, or omit to preserve. Affinity never grants deploy authority. */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Optional 24-hour retry key; reuse with changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** New project name, or omit to preserve. */
    name?: InputMaybe<Scalars['String']['input']>;
    /** New editor pairing preference, or omit to preserve. */
    pairingPreference?: InputMaybe<CrowdyStudioPairingPreference>;
    /** Project UUID to update. */
    projectId: Scalars['String']['input'];
    /** New supported SDK pin, or omit to preserve. */
    sdkVersion?: InputMaybe<Scalars['String']['input']>;
    /** New SERVER module name, explicit null to clear, or omit to preserve. */
    serverModuleName?: InputMaybe<Scalars['String']['input']>;
};
/** A saved (vaulted) off-session payment method. */
export type SavedPaymentMethod = {
    __typename?: 'SavedPaymentMethod';
    /** Card brand, e.g. 'visa'. Null for non-card methods. */
    brand: Maybe<Scalars['String']['output']>;
    /** True when this is the org default method charged off-session. */
    isDefault: Scalars['Boolean']['output'];
    /** Last 4 digits of the card, if applicable. */
    last4: Maybe<Scalars['String']['output']>;
    /** Payment method id (BigInt). */
    paymentMethodId: Scalars['BigInt']['output'];
    /** Payment provider, e.g. 'stripe'. */
    provider: Scalars['String']['output'];
    /** Method status, e.g. 'active' or 'expired'. */
    status: Scalars['String']['output'];
};
/** Arm a one-shot timer that invokes a function after a delay. The target function must be autonomousInvocable, because the timer fires headlessly with no player in the request. */
export type ScheduleInvokeInput = {
    /** The app (tenant). */
    appId: Scalars['BigInt']['input'];
    /** Optional app-scoped key. Re-arming the same key replaces the pending timer instead of adding another, which makes "reset the countdown" a single call. */
    dedupeKey?: InputMaybe<Scalars['String']['input']>;
    /** Delay in milliseconds before the timer fires. Must be at least the app's minTimerDelayMs and at most 30 days. */
    delayMs: Scalars['Int']['input'];
    /** The function to invoke when the timer fires. Must be autonomousInvocable. */
    functionName: Scalars['String']['input'];
    /** JSON object of parameters passed to the delayed invocation. Defaults to '{}'. */
    paramsJson?: InputMaybe<Scalars['String']['input']>;
    /** The 'self' container the delayed invocation runs against. Must belong to the app, and match the function's bound container type when it has one. */
    selfContainerId: Scalars['String']['input'];
    /** Session for the delayed invocation. Defaults to the container's own session. */
    sessionId?: InputMaybe<Scalars['String']['input']>;
};
/** A container (instance) to create as part of a seed. */
export type SeedContainerInput = {
    /** Optional description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Human-friendly display name. */
    displayName: Scalars['String']['input'];
    /** JSON object of metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** Optional owning user id. */
    ownerUserId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Initial property values for the container. */
    properties?: InputMaybe<Array<SeedPropertyInput>>;
    /** Developer-assigned id used only for edge references in this seed. */
    tempId: Scalars['String']['input'];
    /** The container type to instantiate. */
    typeName: Scalars['String']['input'];
};
/** A container type to create as part of a seed. */
export type SeedContainerTypeInput = {
    /** Who may CREATE a container of this type under a client-supplied bindingKey (gameModelEnsureContainer). Same JSON shape as a function invokePolicyJson — an AuthorityRule tree — except that owner_of_self, is_current_turn and condition are refused, because a bind creates the container and there is no acting container to resolve them against. Omit it (the default) and binding is governed by the type's instantiableBy alone, which is the behaviour before this field existed. Resolving an EXISTING key is unaffected: it is a read. For a shared world object, {"type":"is_host"} or instantiableBy: admin stops one player from squatting the key and becoming its owner. */
    bindPolicyJson?: InputMaybe<Scalars['String']['input']>;
    /** public | owner | hidden default for this type's properties. */
    defaultPropertyVisibility?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the type. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Human-friendly display name. */
    displayName: Scalars['String']['input'];
    /** admin | member | owner (who may instantiate this type). */
    instantiableBy?: InputMaybe<Scalars['String']['input']>;
    /** JSON object of metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** Stable type name (unique per app). */
    typeName: Scalars['String']['input'];
};
/** An edge to create between two seeded containers (by temp id). */
export type SeedEdgeInput = {
    /** Source container temp_id (from this seed). */
    fromTempId: Scalars['String']['input'];
    /** JSON object of edge metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** The relationship type label. */
    relationshipType: Scalars['String']['input'];
    /** Target container temp_id (from this seed). */
    toTempId: Scalars['String']['input'];
    /** Optional edge weight. */
    weight?: InputMaybe<Scalars['Float']['input']>;
};
/** A function to create as part of a seed. */
export type SeedFunctionInput = {
    /** Opt-in: allow an autonomous process (automation/NPC) to use this function as an entry point. Defaults to false. */
    autonomousInvocable?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional container type to bind to (omit for a global function). */
    containerTypeName?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the function. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** JSON-encoded invoke-policy rule tree (authority requirements). */
    invokePolicyJson?: InputMaybe<Scalars['String']['input']>;
    /** player | server | internal */
    invokeScope?: InputMaybe<Scalars['String']['input']>;
    /** The property writes the function performs. */
    mutations?: InputMaybe<Array<FunctionMutationInput>>;
    /** Function name (unique per app). */
    name: Scalars['String']['input'];
    /** Declarative realtime notifications the function emits via Buddy after it commits (see notify_* effects). */
    notifications?: InputMaybe<Array<FunctionNotificationInput>>;
    /** Typed parameters the function accepts. */
    parameters?: InputMaybe<Array<FunctionParamInput>>;
    /** Declarative grid-permission effects (grant/revoke runtime grid ACL rows) applied atomically with the function's mutations. Max 4 per function. */
    permissionEffects?: InputMaybe<Array<FunctionPermissionEffectInput>>;
    /** Optional expression whose value becomes the invoke result. */
    returnExpression?: InputMaybe<Scalars['String']['input']>;
    /** Optional declared return value type. */
    returnType?: InputMaybe<Scalars['String']['input']>;
    /** Declarative one-shot timers armed atomically with the function's mutations: invoke another function after a delay. Max 4 per function. */
    timers?: InputMaybe<Array<FunctionTimerInput>>;
};
/** Bulk-create game-model definitions and optional instances in one transaction (model init/import). */
export type SeedGameModelInput = {
    /** The app (tenant) to seed into. */
    appId: Scalars['BigInt']['input'];
    /** Container types to create. */
    containerTypes?: InputMaybe<Array<SeedContainerTypeInput>>;
    /** Containers (instances) to create. */
    containers?: InputMaybe<Array<SeedContainerInput>>;
    /** Edges to create between seeded containers. */
    edges?: InputMaybe<Array<SeedEdgeInput>>;
    /** Functions to create. */
    functions?: InputMaybe<Array<SeedFunctionInput>>;
    /** Property definitions to create. */
    propertyDefinitions?: InputMaybe<Array<SeedPropertyDefInput>>;
    /** Optional session to seed instances into (NULL = app-global). */
    sessionId?: InputMaybe<Scalars['String']['input']>;
};
/** A property definition to create as part of a seed. */
export type SeedPropertyDefInput = {
    /** The container type to define the property on. */
    containerTypeName: Scalars['String']['input'];
    /** JSON-encoded default value. */
    defaultValueJson?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the property. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Property key (unique within the type). */
    key: Scalars['String']['input'];
    /** int | float | string | bool | array | object | container_ref */
    valueType: Scalars['String']['input'];
    /** public | owner | hidden */
    visibility?: InputMaybe<Scalars['String']['input']>;
    /** function | owner | admin */
    writable?: InputMaybe<Scalars['String']['input']>;
};
/** An initial property value for a seeded container. */
export type SeedPropertyInput = {
    /** Property key. */
    key: Scalars['String']['input'];
    /** JSON-encoded value. */
    valueJson: Scalars['String']['input'];
    /** Value type of the value being set. */
    valueType: Scalars['String']['input'];
};
/** An Account Session for Stripe's EMBEDDED Connect components: the browser initializes Connect.js with the publishable key + this short-lived client secret and mounts the account-onboarding / payouts / balances components INSIDE the platform UI — sellers never leave for a Stripe-hosted page. Re-request on expiry. The hosted-link flow (beginSellerOnboarding) remains the fallback. */
export type SellerAccountSession = {
    __typename?: 'SellerAccountSession';
    /** The connected account the session is scoped to (provider ref only). */
    accountRef: Scalars['String']['output'];
    /** Short-lived Account Session client secret for Connect.js. */
    clientSecret: Scalars['String']['output'];
    /** When the client secret expires; re-request after this. */
    expiresAt: Maybe<Scalars['DateTime']['output']>;
    /** Whether onboarding is already complete (payouts enabled) — render the payouts/balances components instead of onboarding. */
    onboardingComplete: Scalars['Boolean']['output'];
    /** Stripe publishable key the browser initializes Connect.js with. */
    publishableKey: Maybe<Scalars['String']['output']>;
};
/** Result of beginning seller onboarding: the Stripe Connect Express account link the seller opens to finish KYC. */
export type SellerOnboardingLink = {
    __typename?: 'SellerOnboardingLink';
    /** The Stripe-hosted onboarding URL to open; null when already complete or unavailable in the seller region. */
    onboardingUrl: Maybe<Scalars['String']['output']>;
    /** Current onboarding state. */
    status: SellerOnboardingStatus;
    /** Why onboarding is unavailable (e.g. region unsupported); null otherwise. */
    unavailableReason: Maybe<Scalars['String']['output']>;
};
/** A seller (player or org) payout-account state: NONE (never started), PENDING (Stripe Connect Express onboarding incomplete), COMPLETE (payouts enabled), or BLOCKED (provider or platform hold). */
export declare enum SellerOnboardingStatus {
    Blocked = "BLOCKED",
    Complete = "COMPLETE",
    None = "NONE",
    Pending = "PENDING"
}
/** A seller's payout balance (player or org). pending ages through the D6 delay window into payable; reserved is the D6 young-account holdback or a T11 freeze. */
export type SellerPayoutBalance = {
    __typename?: 'SellerPayoutBalance';
    /** Stripe Connect Express onboarding state. */
    onboardingStatus: SellerOnboardingStatus;
    /** 'user' or 'org'. */
    partyKind: Scalars['String']['output'];
    /** User id or org id. */
    partyRef: Scalars['BigInt']['output'];
    /** Cents aged, unreserved, and withdrawable. */
    payableCents: Scalars['Int']['output'];
    /** Whether payouts are frozen by a T11 review hold. */
    payoutsFrozen: Scalars['Boolean']['output'];
    /** Cents still aging in the delay window. */
    pendingCents: Scalars['Int']['output'];
    /** Cents held back (reserve or T11 freeze). */
    reservedCents: Scalars['Int']['output'];
};
/** Accept one bounded human message and queue exactly one serialized run. */
export type SendAgentMessageInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Human intent text, normalized, secret-scanned, and capped at 16 KiB. It never grants authority. */
    content: Scalars['String']['input'];
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Owner/app active session UUID. */
    sessionId: Scalars['String']['input'];
};
/** Result of an operator test send. */
export type SendTestEmailResult = {
    __typename?: 'SendTestEmailResult';
    /** The SES message id when a message was actually handed to SES. Null when sending is disabled on this instance, which is reported as sent=true by the same rule the product flows use, so READ THIS FIELD to tell a real send from a simulated one. */
    messageId: Maybe<Scalars['String']['output']>;
    /** Why a send was refused, when it was. */
    refusedReason: Maybe<Scalars['String']['output']>;
    /** Whether the send was attempted AND accepted. False means refused (suppressed domain, or a prior permanent bounce) or that SES rejected it. */
    sent: Scalars['Boolean']['output'];
    /** True when SEND_EMAILS is off and the message was logged rather than sent. sent=true with simulated=true means nothing left the building. */
    simulated: Scalars['Boolean']['output'];
};
/** Notification received when the server sends a custom event. Received via the udpNotifications subscription. */
export type ServerEventNotification = {
    __typename?: 'ServerEventNotification';
    /** The ID of the app where the event is occurring. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk where the event is located. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk where the event is located. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk where the event is located. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The event type ID (uint16). This determines how the event should be processed. */
    eventType: Scalars['Int']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** The event state data, base64-encoded. The format is defined by the event type. */
    state: Scalars['String']['output'];
    /** The unique identifier of the object controlling this event. */
    uuid: Scalars['String']['output'];
};
/** Lifecycle/capacity state of a game/GraphQL server in the fleet. Only ReadyForClients servers should receive new client connections; serverWithLeastClients and activeGraphQLServers already filter to healthy, non-overloaded servers. */
export declare enum ServerState {
    /** Hard resource overload. Like NearCapacity (excluded from new-client selection), and the server is also actively shedding clients: it sends each affected client a reconnect command and drops their session after a short grace period so they migrate to another server. */
    Full = "Full",
    /** Soft resource overload (a CPU core or system memory has been high for several seconds). Existing sessions continue, but the server is excluded from serverWithLeastClients so no new clients are routed here until it recovers. */
    NearCapacity = "NearCapacity",
    /** The server is down or unreachable (failed health checks). Do not route any traffic here. */
    Offline = "Offline",
    /** The server is healthy and accepting clients. This is the only state safe to route new connections to. */
    ReadyForClients = "ReadyForClients",
    /** The server is booting and not yet accepting clients. Do not route new connections here; wait for ReadyForClients. */
    Starting = "Starting",
    /** The server is draining and shutting down: existing sessions may continue briefly but no new clients should be routed here. */
    Stopping = "Stopping"
}
/** Live status and load/telemetry for one UDP game server (Buddy) in the fleet. Returned by serverWithLeastClients (which picks a low-load ReadyForClients server). Throughput metrics are per-second samples from the last reporting window and are null until first reported. */
export type ServerStatus = {
    __typename?: 'ServerStatus';
    /** UDP port that native clients send spatial datagrams to (typically 9091). Browser clients do not use this directly — they reach the server through the UDP proxy / udpNotifications. */
    clientPort: Scalars['Int']['output'];
    /** Bytes per second received from clients in the last reporting window. Null until reported. */
    clientRecvBytesPerSec: Maybe<Scalars['Float']['output']>;
    /** Messages per second received from clients in the last reporting window. Null until reported. */
    clientRecvMsgsPerSec: Maybe<Scalars['Float']['output']>;
    /** Bytes per second sent to clients in the last reporting window. Null until reported. */
    clientSendBytesPerSec: Maybe<Scalars['Float']['output']>;
    /** Per-second rate of individually-addressed (single-actor) messages sent to clients in the last window, as opposed to spatial fan-out. Null until reported. */
    clientSendIndividualMsgsPerSec: Maybe<Scalars['Float']['output']>;
    /** Messages per second sent to clients in the last reporting window. Null until reported. */
    clientSendMsgsPerSec: Maybe<Scalars['Float']['output']>;
    /** Number of game clients currently connected to this server. serverWithLeastClients balances on this DIVIDED BY routerThreads, not on the raw count, so that a server with four fan-out workers takes roughly four times the clients of a server with one. */
    clients: Scalars['Int']['output'];
    /** CPU cores available to this server. Reported by the server itself; null on a build that predates capacity reporting. Informational — client balancing divides by routerThreads, not by cores. */
    cpuCount: Maybe<Scalars['Int']['output']>;
    /** Peak CPU utilization percentage (0-100) observed in the last reporting window. Null until reported. */
    cpuPeakPct: Maybe<Scalars['Float']['output']>;
    /** When this server was first registered in the fleet. */
    createdAt: Scalars['DateTime']['output'];
    /** True while the infra control plane is taking this server out of service (autoscale scale-in, or an in-place update). Excluded from serverWithLeastClients immediately; the server then reports Stopping and sends every client a reconnect command so they migrate elsewhere. Never set by the server itself. */
    drainRequested: Scalars['Boolean']['output'];
    /** IPv4 address native clients send spatial UDP datagrams to (paired with clientPort). Preferred over ip6 for inter-host UDP in current deployments. */
    ip4: Scalars['String']['output'];
    /** IPv6 address of the UDP game server. Global IPv6 between hosts can be unroutable in some deployments, so native clients generally use ip4 + clientPort. */
    ip6: Scalars['String']['output'];
    /** Bytes per second received from peer servers (server-to-server P2P) in the last reporting window. Null until reported. */
    peerRecvBytesPerSec: Maybe<Scalars['Float']['output']>;
    /** Messages per second received from peer servers (server-to-server P2P) in the last reporting window. Null until reported. */
    peerRecvMsgsPerSec: Maybe<Scalars['Float']['output']>;
    /** Bytes per second sent to peer servers (server-to-server P2P) in the last reporting window. Null until reported. */
    peerSendBytesPerSec: Maybe<Scalars['Float']['output']>;
    /** Messages per second sent to peer servers (server-to-server P2P) in the last reporting window. Null until reported. */
    peerSendMsgsPerSec: Maybe<Scalars['Float']['output']>;
    /** Number of peer (server-to-server P2P) connections this server currently holds. */
    peers: Scalars['Int']['output'];
    /** Independent fan-out workers (RouterWorkers) on this server, which is how much of it there is for the purpose of placing a client. serverWithLeastClients divides the client count by this value. Null on a build that predates capacity reporting, and treated as 1, which balances every server equally as before. */
    routerThreads: Maybe<Scalars['Int']['output']>;
    /** Unique id of this game-server row in the fleet registry (the Buddy instance uuid). */
    serverId: Scalars['ID']['output'];
    /** Current lifecycle state of this server (see ServerState). Only ReadyForClients servers accept new clients. */
    status: ServerState;
    /** When this status row was last updated (server heartbeat). Use to judge how fresh the metrics/state are. */
    updatedAt: Scalars['DateTime']['output'];
};
/** Server version plus the minimum client version the server will accept. A client whose build is older than minimumClientVersion should prompt the user to update before connecting. */
export type ServerVersionInfo = {
    __typename?: 'ServerVersionInfo';
    /** Minimum accepted client version */
    minimumClientVersion: VersionInfo;
    /** Current server version */
    serverVersion: VersionInfo;
};
export type ServiceQuota = {
    __typename?: 'ServiceQuota';
    /** What happens when the limit is exceeded. Free-form string; defaults to "throttle" (typical values: "throttle" to rate-limit, "block" to reject). */
    actionOnExceed: Scalars['String']['output'];
    /** App this rule is scoped to (BigInt as a decimal string); null if not app-scoped. */
    appId: Maybe<Scalars['BigInt']['output']>;
    /** When the rule was created (ISO-8601 UTC timestamp). */
    createdAt: Scalars['DateTime']['output'];
    /** Maximum allowed amount of the metric per `period`, as a BigInt decimal string. */
    limitValue: Scalars['BigInt']['output'];
    /** The metered resource this rule limits (e.g. "api_requests", "storage_bytes"). Free-form metric key, matched exactly. */
    metric: Scalars['String']['output'];
    /** Organization this rule is scoped to (BigInt as a decimal string); null if not org-scoped. */
    orgId: Maybe<Scalars['BigInt']['output']>;
    /** Time window the limit applies over. Free-form string; defaults to "per_minute" (typical values: "per_minute", "per_hour", "per_day"). */
    period: Scalars['String']['output'];
    /** Unique quota rule id (BigInt as a decimal string). */
    quotaId: Scalars['BigInt']['output'];
    /** Access tier this rule is scoped to (BigInt as a decimal string); null if not tier-scoped. */
    tierId: Maybe<Scalars['BigInt']['output']>;
    /** When the rule was last updated (ISO-8601 UTC timestamp). */
    updatedAt: Scalars['DateTime']['output'];
};
/** Atomically select human mode plus optional project/grid and repin effective policy revisions, descriptors, registry digest, and context while preempting old authority. */
export type SetAgentModeInput = {
    /** Current attached client epoch. */
    clientEpoch: Scalars['BigInt']['input'];
    /** Optional grid context to atomically repin with the mode. Omit to retain it; PLAY requires the resulting grid. */
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Required retry key. Same owner, operation, key, and input replay the first result; changed input returns IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** New human-selected mode; the model cannot call this mutation. */
    mode: CrowdyStudioAgentMode;
    /** Optional owner project UUID to atomically repin with the mode. Omit to retain it; BUILD requires the resulting selection. */
    projectId?: InputMaybe<Scalars['String']['input']>;
    /** Owner/app session UUID. */
    sessionId: Scalars['String']['input'];
};
/** 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). */
    appId: Scalars['BigInt']['input'];
    /** App-wide kill switch. */
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    /** Max aggregate runs per minute for the app. */
    globalRunsPerMinute?: InputMaybe<Scalars['Int']['input']>;
    /** Max automations the app may define. */
    maxAutomations?: InputMaybe<Scalars['Int']['input']>;
    /** Max event-trigger cascade depth. */
    maxCascadeDepth?: InputMaybe<Scalars['Int']['input']>;
    /** Max fan-out targets per run. */
    maxFanout?: InputMaybe<Scalars['Int']['input']>;
    /** Max pending (armed but not yet fired) timers the app may hold at once. */
    maxPendingTimers?: InputMaybe<Scalars['Int']['input']>;
    /** Minimum schedule interval (ms) floor. */
    minIntervalMs?: InputMaybe<Scalars['Int']['input']>;
    /** Minimum timer delay (ms) floor for gameModelScheduleInvoke and function timer effects. */
    minTimerDelayMs?: InputMaybe<Scalars['Int']['input']>;
};
/** Set the per-app channel creation/membership policy (app-admin only). */
export type SetChannelPolicyInput = {
    /** The app (tenant) whose channel policy to set. */
    appId: Scalars['BigInt']['input'];
    /** admin | member | anyone. Who may create channels in this app. */
    creationPolicy?: InputMaybe<Scalars['String']['input']>;
    /** open | request | invite | admin. Default membership policy for new channels. */
    defaultMembershipPolicy?: InputMaybe<Scalars['String']['input']>;
    /** Optional cap on how many channels a single user may belong to (null = unlimited). */
    maxGroupsPerUser?: InputMaybe<Scalars['Int']['input']>;
    /** Optional cap on members per channel (null = unlimited). */
    maxMembers?: InputMaybe<Scalars['Int']['input']>;
};
/** Set the per-app compute policy (guardrails / platform ceilings). Omitted fields keep their current (or default) values. */
export type SetComputePolicyInput = {
    /** The app (tenant). */
    appId: Scalars['BigInt']['input'];
    /** Cooldown (ms) while a module circuit is open. */
    cooldownMs?: InputMaybe<Scalars['Int']['input']>;
    /** App-wide kill switch for all compute modules. */
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    /** Consecutive failures that open a module circuit. */
    failureThreshold?: InputMaybe<Scalars['Int']['input']>;
    /** Fuel budget per invoke/event call. */
    fuelPerInvoke?: InputMaybe<Scalars['BigInt']['input']>;
    /** Fuel budget per tick call. */
    fuelPerTick?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max host data-API operations per tick. */
    maxDbOpsPerTick?: InputMaybe<Scalars['Int']['input']>;
    /** Max replication bytes a module may emit per minute. */
    maxEgressBytesPerMin?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max replication messages a module may emit per minute. */
    maxEgressMsgsPerMin?: InputMaybe<Scalars['Int']['input']>;
    /** Max guest linear memory (MB). */
    maxMemoryMb?: InputMaybe<Scalars['Int']['input']>;
    /** Max modules the app may define. */
    maxModules?: InputMaybe<Scalars['Int']['input']>;
    /** Wall-clock watchdog budget per entry call (ms). */
    maxRunMs?: InputMaybe<Scalars['Int']['input']>;
    /** Max state bytes a module may write per minute. */
    maxStateBytesPerMin?: InputMaybe<Scalars['BigInt']['input']>;
    /** Max state saves a module may write per minute. */
    maxStateWritesPerMin?: InputMaybe<Scalars['Int']['input']>;
    /** Max tick rate (Hz) any module may request. */
    maxTickHz?: InputMaybe<Scalars['Float']['input']>;
    /** Minimum gap in milliseconds between saves of a module’s state. Saves made inside the window are combined and the newest one is written, so a module that saves every tick still only writes once per window. */
    statePersistMinIntervalMs?: InputMaybe<Scalars['Int']['input']>;
};
/** Set one property value on a container directly. */
export type SetContainerPropertyInput = {
    /** The app (tenant) that owns the container. */
    appId: Scalars['BigInt']['input'];
    /** The container id to write to. */
    containerId: Scalars['String']['input'];
    /** The property key to write. */
    key: Scalars['String']['input'];
    /** JSON-encoded value. */
    valueJson: Scalars['String']['input'];
    /** The value type being written (must match the property definition). */
    valueType: Scalars['String']['input'];
};
/** Patch an app's Agentic Studio policy. Requires manage_compute. Omitted fields stay unchanged; all supplied authority and limits are clamped to platform policy. */
export type SetCrowdyStudioAgentAppPolicyInput = {
    /** Replacement exact model allowlist (max 64). On an APP patch every id must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list; values are never silently dropped. On the PLATFORM patch this list IS the ceiling. Empty denies all models at either layer. */
    allowedModelIds?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Replacement mode allowlist. On an APP patch every mode must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list. Empty denies every mode at either layer; there is no inherit-on-empty for modes. */
    allowedModes?: InputMaybe<Array<CrowdyStudioAgentMode>>;
    /** Replacement risk-class allowlist. On an APP patch every class must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list, and what you do send is stored exactly as sent; OMIT the field to express no narrowing, which inherits the platform list live on every read. On the PLATFORM patch this list is the ceiling and empty denies every class. */
    allowedRiskClasses?: InputMaybe<Array<CrowdyStudioAgentRiskClass>>;
    /** Replacement exact logical tool-name allowlist (max 256). On an APP patch every name must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list, and what you do send is stored exactly as sent; OMIT the field to express no narrowing, which inherits the platform list live on every read. Sending an empty array on an APP patch clears a narrowing and is therefore also "no narrowing", not "deny all". On the PLATFORM patch this list is the ceiling and empty denies every tool. */
    allowedToolNames?: InputMaybe<Array<Scalars['String']['input']>>;
    /** App whose policy is changed. */
    appId: Scalars['BigInt']['input'];
    /** Enable or disable this policy layer. */
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional optimistic revision. Use 0 when creating; a mismatch fails AGENT_POLICY_REVISION_CONFLICT. */
    expectedRevision?: InputMaybe<Scalars['BigInt']['input']>;
    /** Required retry key (1-128 characters). Same key/arguments replay; different arguments fail IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Set or clear this layer kill switch. Kill always wins over enablement. */
    killSwitch?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional per-player/day and concurrency limit patch. */
    playerDayLimits?: InputMaybe<CrowdyStudioAgentPlayerDayLimitsInput>;
    /** Optional private-source sharing patch; first-use consent remains locked on. */
    privacy?: InputMaybe<CrowdyStudioAgentPrivacyPolicyInput>;
    /** Optional retention patch. */
    retention?: InputMaybe<CrowdyStudioAgentRetentionPolicyInput>;
    /** Optional per-session limit patch. */
    sessionLimits?: InputMaybe<CrowdyStudioAgentSessionLimitsInput>;
    /** Optional per-turn limit patch. */
    turnLimits?: InputMaybe<CrowdyStudioAgentTurnLimitsInput>;
};
/** Operator-only per-app emergency kill. App managers cannot clear or override this state. */
export type SetCrowdyStudioAgentOperatorAppKillInput = {
    /** App to kill or release. */
    appId: Scalars['BigInt']['input'];
    /** Optional optimistic app-policy revision. */
    expectedRevision?: InputMaybe<Scalars['BigInt']['input']>;
    /** Required retry key (1-128 characters). Same key/arguments replay; different arguments fail IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** True to kill immediately; false to release the operator kill. */
    killed: Scalars['Boolean']['input'];
    /** Safe reason text (max 256); no secrets or provider bodies. */
    reason?: InputMaybe<Scalars['String']['input']>;
    /** Stable reason code (max 64); defaults to AGENT_OPERATOR_KILLED. */
    reasonCode?: InputMaybe<Scalars['String']['input']>;
};
/** Operator-only platform policy patch. Omitted values stay unchanged; hard v1 privacy and retention maxima still apply. */
export type SetCrowdyStudioAgentPlatformPolicyInput = {
    /** Replacement exact model allowlist (max 64). On an APP patch every id must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list; values are never silently dropped. On the PLATFORM patch this list IS the ceiling. Empty denies all models at either layer. */
    allowedModelIds?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Replacement mode allowlist. On an APP patch every mode must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list. Empty denies every mode at either layer; there is no inherit-on-empty for modes. */
    allowedModes?: InputMaybe<Array<CrowdyStudioAgentMode>>;
    /** Replacement risk-class allowlist. On an APP patch every class must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list, and what you do send is stored exactly as sent; OMIT the field to express no narrowing, which inherits the platform list live on every read. On the PLATFORM patch this list is the ceiling and empty denies every class. */
    allowedRiskClasses?: InputMaybe<Array<CrowdyStudioAgentRiskClass>>;
    /** Replacement exact logical tool-name allowlist (max 256). On an APP patch every name must already be in the platform allowlist or the whole write is refused with AGENT_POLICY_INVALID naming that list, and what you do send is stored exactly as sent; OMIT the field to express no narrowing, which inherits the platform list live on every read. Sending an empty array on an APP patch clears a narrowing and is therefore also "no narrowing", not "deny all". On the PLATFORM patch this list is the ceiling and empty denies every tool. */
    allowedToolNames?: InputMaybe<Array<Scalars['String']['input']>>;
    /** Enable or disable this policy layer. */
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional optimistic platform revision. */
    expectedRevision?: InputMaybe<Scalars['BigInt']['input']>;
    /** Required retry key (1-128 characters). Same key/arguments replay; different arguments fail IDEMPOTENCY_CONFLICT. */
    idempotencyKey: Scalars['String']['input'];
    /** Safe operator-facing kill reason (max 256); no secrets or provider bodies. */
    killReason?: InputMaybe<Scalars['String']['input']>;
    /** Stable kill reason code (max 64); used only while killSwitch is true. */
    killReasonCode?: InputMaybe<Scalars['String']['input']>;
    /** Set or clear this layer kill switch. Kill always wins over enablement. */
    killSwitch?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional per-player/day and concurrency limit patch. */
    playerDayLimits?: InputMaybe<CrowdyStudioAgentPlayerDayLimitsInput>;
    /** Optional private-source sharing patch; first-use consent remains locked on. */
    privacy?: InputMaybe<CrowdyStudioAgentPrivacyPolicyInput>;
    /** Optional retention patch. */
    retention?: InputMaybe<CrowdyStudioAgentRetentionPolicyInput>;
    /** Optional per-session limit patch. */
    sessionLimits?: InputMaybe<CrowdyStudioAgentSessionLimitsInput>;
    /** Optional per-turn limit patch. */
    turnLimits?: InputMaybe<CrowdyStudioAgentTurnLimitsInput>;
};
/** Optimistically archive or restore one caller-owned personal-library file. */
export type SetCrowdyStudioLibraryFileArchivedInput = {
    /** App tenant that owns the private library entry. */
    appId: Scalars['BigInt']['input'];
    /** True to archive; false to make the entry active again. */
    archived: Scalars['Boolean']['input'];
    /** Current library revision required for optimistic concurrency. */
    expectedRevision: Scalars['BigInt']['input'];
    /** Optional 24-hour retry key. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Personal-library file UUID. */
    libraryFileId: Scalars['String']['input'];
};
/** Optimistically archive or unarchive one private project without deleting its files or provenance. */
export type SetCrowdyStudioProjectArchivedInput = {
    /** App tenant that owns the private project. */
    appId: Scalars['BigInt']['input'];
    /** True to archive; false to restore the project. */
    archived: Scalars['Boolean']['input'];
    /** Current project revision required for optimistic concurrency. */
    expectedRevision: Scalars['BigInt']['input'];
    /** Optional 24-hour retry key. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Project UUID to archive or restore. */
    projectId: Scalars['String']['input'];
};
/** Set the app's game-model runtime policy. */
export type SetGameModelPolicyInput = {
    /** The app (tenant) whose policy to set. */
    appId: Scalars['BigInt']['input'];
    /** Default role assigned to new session participants. */
    defaultParticipantRole?: InputMaybe<Scalars['String']['input']>;
    /** admin | member | anyone */
    sessionCreationPolicy?: InputMaybe<Scalars['String']['input']>;
};
/** Set the per-grid permission-key whitelist (writes the grid_permission_limits input table). */
export type SetGridPermissionLimitsInput = {
    /** The app (tenant) that owns the grid. */
    appId: Scalars['BigInt']['input'];
    /** The grid whose whitelist to set. */
    gridId: Scalars['BigInt']['input'];
    /** The whitelist of permission keys allowed on this grid. Empty array removes all limits (every active grid permission becomes grantable again). Each key must be a known runtime permission key, unique, and at most 64 chars. */
    permissionKeys: Array<Scalars['String']['input']>;
};
export type SetListingPricingInput = {
    /** Acquisition mode: 'free', 'buy', 'rent', 'time_limited', or 'cost_limited'. */
    acquisitionMode: Scalars['String']['input'];
    /** App that owns the listing. */
    appId: Scalars['BigInt']['input'];
    /** Whether an acquired license may travel with a grid resale (default false; 07 §5.a). */
    licenseTransferable?: InputMaybe<Scalars['Boolean']['input']>;
    /** UUID of the listing to price. */
    listingId: Scalars['String']['input'];
    /** Price in cents (required for all non-free modes; author-set only). */
    priceCents?: InputMaybe<Scalars['Int']['input']>;
    /** Rent billing interval in days (rent mode). */
    rentIntervalDays?: InputMaybe<Scalars['Int']['input']>;
    /** Compute-unit budget the license grants (cost_limited mode). */
    unitBudget?: InputMaybe<Scalars['BigInt']['input']>;
    /** Single fixed window in days (time_limited mode). */
    windowDays?: InputMaybe<Scalars['Int']['input']>;
};
/** Replace a member's roles in a group (the listed roles become their full set). */
export type SetMemberRolesInput = {
    /** The group (team/channel) id. */
    groupId: Scalars['BigInt']['input'];
    /** The complete set of group role ids the member should have. Roles not listed are removed; unknown ids or ids from other groups are ignored. */
    roleIds: Array<Scalars['BigInt']['input']>;
    /** The member (user) whose roles to set. */
    userId: Scalars['BigInt']['input'];
};
/** Enable or disable one player automation. Enabling a schedule computes its next due time. */
export type SetPlayerAutomationEnabledInput = {
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Player automation UUID. */
    automationId: Scalars['String']['input'];
    /** Whether the automation may dispatch. */
    enabled: Scalars['Boolean']['input'];
    /** Grid that confines the automation. */
    gridId: Scalars['BigInt']['input'];
};
/** Set one arbitrary JSON property on a player-owned container. The caller must currently own the specified grid and container. */
export type SetPlayerModelPropertyInput = {
    /** App containing the owned grid. */
    appId: Scalars['BigInt']['input'];
    /** Player container UUID. */
    containerId: Scalars['String']['input'];
    /** Grid that confines the container. */
    gridId: Scalars['BigInt']['input'];
    /** Property key, upserted within the container. */
    propertyKey: Scalars['String']['input'];
    /** JSON-encoded property value. Any valid JSON value is accepted. */
    valueJson: Scalars['String']['input'];
};
/** Upsert one player policy row. Omitted knobs keep their current value (or the platform default on first insert). unitsPerHour/unitsPerDay accept null to clear the quota. */
export type SetPlayerWasmPolicyInput = {
    /** The app. */
    appId: Scalars['BigInt']['input'];
    clientFuelPerDispatch?: InputMaybe<Scalars['BigInt']['input']>;
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    fuelPerInvoke?: InputMaybe<Scalars['BigInt']['input']>;
    fuelPerTick?: InputMaybe<Scalars['BigInt']['input']>;
    maxCompilesPerHour?: InputMaybe<Scalars['Int']['input']>;
    maxContainerCreatesDay?: InputMaybe<Scalars['Int']['input']>;
    maxDbOpsPerTick?: InputMaybe<Scalars['Int']['input']>;
    maxEgressBytesPerMin?: InputMaybe<Scalars['BigInt']['input']>;
    maxEgressMsgsPerMin?: InputMaybe<Scalars['Int']['input']>;
    maxMemoryMb?: InputMaybe<Scalars['Int']['input']>;
    maxModulesPerGrid?: InputMaybe<Scalars['Int']['input']>;
    maxModulesTotal?: InputMaybe<Scalars['Int']['input']>;
    maxRunMs?: InputMaybe<Scalars['Int']['input']>;
    maxTickHz?: InputMaybe<Scalars['Float']['input']>;
    /** 'app_default', 'tier', 'grid', or 'user'. */
    scope: Scalars['String']['input'];
    /** Tier/grid/user id; required unless scope is app_default. */
    scopeRef?: InputMaybe<Scalars['BigInt']['input']>;
    unitsPerDay?: InputMaybe<Scalars['BigInt']['input']>;
    unitsPerHour?: InputMaybe<Scalars['BigInt']['input']>;
};
export type SetQuotaInput = {
    /** What to do when the limit is exceeded. Optional; defaults to "throttle" (typical values: "throttle" to rate-limit, "block" to reject). */
    actionOnExceed?: InputMaybe<Scalars['String']['input']>;
    /** Scope the rule to this app (BigInt as a decimal string). */
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Optional idempotency key. Recommended for retries: replaying with the same key and identical input returns the first result instead of re-applying; the same key with different input returns IDEMPOTENCY_CONFLICT. Keys expire after 24h. */
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
    /** Maximum allowed amount of the metric per `period`, as a BigInt decimal string. */
    limitValue: Scalars['BigInt']['input'];
    /** The metered resource key to limit (max 64 characters), e.g. "api_requests". */
    metric: Scalars['String']['input'];
    /** Scope the rule to this organization (BigInt as a decimal string). Provide one of orgId/appId/tierId to choose the scope; omit all three for a global (super-admin) rule. */
    orgId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Time window the limit applies over. Optional; defaults to "per_minute" (typical values: "per_minute", "per_hour", "per_day"). Part of the upsert key, so different periods create separate rules. */
    period?: InputMaybe<Scalars['String']['input']>;
    /** Scope the rule to this access tier (BigInt as a decimal string). */
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
};
export type SetRateCardInput = {
    /** Required when a unit change also changes the money. Restating 15c per GiB as 1.396984c per 100 MB is the same price and needs nothing; changing 20c per 100 MB to 20c per GiB-month is a 7841x cut and must be stated deliberately. The mutation refuses rather than guessing which one you meant. */
    acknowledgeRepricing?: InputMaybe<Scalars['Boolean']['input']>;
    /** New hourly free allowance in raw metric units, as a BigInt decimal string. Must be >= 0. Omit to leave the allowance unchanged. */
    freePerHour?: InputMaybe<Scalars['BigInt']['input']>;
    /** New monthly free allowance in raw metric units, as a BigInt decimal string. Must be >= 0. On the PLAYER card with metric player_wasm_compute_units this is the pooled monthly TRIAL BUDGET per (player, app) — the only sanctioned way to change it on a live tier. Omit to leave it unchanged. */
    freePerMonth?: InputMaybe<Scalars['BigInt']['input']>;
    /** The metered dimension to reprice. Refused unless the platform actually meters it: a rate for an unmetered metric bills nobody while appearing configured. */
    metric: Scalars['String']['input'];
    /** New price in cents per unitQuantity raw units. Must be >= 0; 0 means meter but do not charge. Omit to leave the price unchanged. Fractional values are accepted (the column is NUMERIC(20,6)). */
    priceCents?: InputMaybe<Scalars['Float']['input']>;
    /** Why this price is changing. Required: a rate change with no stated reason is not auditable after the fact. Recorded in the operator log with the before and after values. */
    reason: Scalars['String']['input'];
    /** Which card to edit. */
    scope: RateScope;
    /** New human unit this price is quoted in, e.g. "GiB" or "GiB-mo". Must be supplied together with unitQuantity: a label on its own restates the rate card while the arithmetic keeps the old divisor. Omit both to leave the unit unchanged. */
    unitLabel?: InputMaybe<Scalars['String']['input']>;
    /** New number of raw metric units one priceCents charge covers, as a BigInt decimal string. Must be > 0 and supplied together with unitLabel. Needed because every rate seed is ON CONFLICT DO NOTHING, so a unit corrected in the declaration never reaches a tier that is already installed. */
    unitQuantity?: InputMaybe<Scalars['BigInt']['input']>;
};
/** The result of setting a rate: the new row and what moved. */
export type SetRateCardResult = {
    __typename?: 'SetRateCardResult';
    /** One entry per field that changed. Never empty: a call that would change nothing is refused rather than reported as a successful no-op. */
    changes: Array<RateChangeType>;
    /** The dimension as it now stands. */
    entry: RateCardEntryType;
};
/** Set or clear the current-turn user of a session. */
export type SetSessionTurnInput = {
    /** The app (tenant) that owns the session. */
    appId: Scalars['BigInt']['input'];
    /** The session id to update. */
    sessionId: Scalars['String']['input'];
    /** The user whose turn it now is (NULL clears the turn). */
    userId?: InputMaybe<Scalars['BigInt']['input']>;
};
/** Set the per-app team creation/membership policy (app-admin only). */
export type SetTeamPolicyInput = {
    /** The app (tenant) whose team policy to set. */
    appId: Scalars['BigInt']['input'];
    /** admin | member | anyone. Who may create teams in this app. */
    creationPolicy?: InputMaybe<Scalars['String']['input']>;
    /** open | request | invite | admin. Default membership policy for new teams. */
    defaultMembershipPolicy?: InputMaybe<Scalars['String']['input']>;
    /** Optional cap on how many teams a single user may belong to (null = unlimited). */
    maxGroupsPerUser?: InputMaybe<Scalars['Int']['input']>;
    /** Optional cap on members per team (null = unlimited). */
    maxMembers?: InputMaybe<Scalars['Int']['input']>;
};
/** @deprecated Legacy monthly app-slot subscription plan. New shared publishes use wallet usage billing. */
export type SharedEnvPlan = {
    __typename?: 'SharedEnvPlan';
    /** Billing cadence, e.g. 'month' or 'year'. */
    billingInterval: Scalars['String']['output'];
    /** Stable machine-readable plan code. */
    code: Scalars['String']['output'];
    /** ISO-4217 currency for priceCents, e.g. 'USD'. */
    currency: Scalars['String']['output'];
    description: Maybe<Scalars['String']['output']>;
    /** Human-readable plan name. */
    name: Scalars['String']['output'];
    /** Plan id (BigInt). */
    planId: Scalars['BigInt']['output'];
    /** Recurring price per billing interval, in cents. */
    priceCents: Scalars['BigInt']['output'];
    /** Plan status, e.g. 'active' (offered) or 'archived'. */
    status: Scalars['String']['output'];
};
/** Input for sending an actor-to-actor message: a message delivered only to the single actor identified by targetUuid. It is spatially routed (the sender must know the destination actor’s chunk), but unlike normal spatial messages it is NOT broadcast to other nearby actors and has no distance/decay. */
export type SingleActorMessageInput = {
    /** The ID of the app the destination actor belongs to. */
    appId: Scalars['BigInt']['input'];
    /** The chunk coordinates of the DESTINATION actor (where the target currently is). The sender must know this. */
    chunk: ChunkCoordinatesInput;
    /** The message payload, base64-encoded. Opaque to the server; the sender’s identity (if needed) must be embedded here by the application. */
    payload: Scalars['String']['input'];
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on any GenericErrorResponse for this send, delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** The DESTINATION actor’s UUID. The message is delivered only to the client that owns this actor. Must be exactly 32 bytes when encoded as UTF-8. */
    targetUuid: Scalars['String']['input'];
};
/** Notification received when another actor sends you a direct actor-to-actor message (SINGLE_ACTOR_MESSAGE). Delivered only to the targeted actor via the udpNotifications subscription. */
export type SingleActorMessageNotification = {
    __typename?: 'SingleActorMessageNotification';
    /** The ID of the app the message was sent within. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the destination chunk. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the destination chunk. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the destination chunk. */
    chunkZ: Scalars['BigInt']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The message payload, base64-encoded. Opaque to the server; decode per your application protocol. */
    payload: Scalars['String']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** 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';
    /** Replay durable events with seq greater than afterSeq, then tail newly committed facts using database replay plus in-memory wakeups. Requires an app-scoped owner, use_studio_agent, and exact current clientEpoch. Delivery is ordered and at-least-once: deduplicate eventId/seq, fill gaps with crowdyStudioAgentHistory, and acknowledge only contiguous sequences. */
    crowdyStudioAgentEvents: CrowdyStudioAgentEvent;
    /** Stream complete active gameplay-session count transitions for one app. There is no bootstrap event: query gameModelActivePlayerCount for the current snapshot. The first complete sample is a silent baseline; PARTIAL/UNAVAILABLE samples do not emit or become zero. Delivery uses a Postgres-backed cross-replica best-effort feed with a bounded oldest-drop buffer. Deduplicate by revision; after reconnect or a revision gap, requery gameModelActivePlayerCount. Requires an app-scoped token for this exact app. */
    gameModelActivePlayerCountChanged: GameModelActivePlayerCountChange;
    /** Push notification whenever a container in the app changes: an invoke mutated it, a direct gameModelSetProperty wrote it, or it was created/deleted. Metadata only (containerId, typeName, changedKeys — no property values); pull the visibility-filtered state with gameModelContainerState on receipt. Post-commit and best-effort (a dropped event costs one missed pull, never correctness) — durable reads remain the source of truth. Optional typeName/sessionId filters narrow delivery. Fans out across all API replicas. Requires a valid token. Replaces interval polling with pull-on-push. */
    gameModelContainerChanged: GmContainerChange;
    /** 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. */
    udpNotifications: Maybe<UdpNotification>;
};
export type SubscriptionCrowdyStudioAgentEventsArgs = {
    afterSeq: Scalars['BigInt']['input'];
    clientEpoch: Scalars['BigInt']['input'];
    sessionId: Scalars['String']['input'];
};
export type SubscriptionGameModelActivePlayerCountChangedArgs = {
    appId: Scalars['BigInt']['input'];
};
export type SubscriptionGameModelContainerChangedArgs = {
    appId: Scalars['BigInt']['input'];
    sessionId?: InputMaybe<Scalars['String']['input']>;
    typeName?: InputMaybe<Scalars['String']['input']>;
};
export type TeleportRequestInput = {
    /** App (game) to teleport within. Must be greater than 0 (a non-positive value yields errorCode INVALID_APP_ID). BigInt sent as a decimal string. */
    appId: Scalars['BigInt']['input'];
    /** Destination chunk-grid coordinates (x, y, z as int64 BigInt decimal strings). The reserved sentinel (-6, -6, -6) is rejected as UNAUTHORIZED. */
    chunkAddress: ChunkCoordinatesInput;
    /** Actor being teleported: exactly 32 ASCII characters (the UDP-wire actor id), NOT a hyphenated RFC-4122 UUID. */
    uuid: Scalars['String']['input'];
    /** Destination voxel coordinates within the chunk (x, y, z as signed 16-bit ints, -32768..32767). */
    voxelAddress: VoxelCoordinatesInput;
};
export type TeleportResponse = {
    __typename?: 'TeleportResponse';
    /** ErrorType enum: NO_ERROR on success; INVALID_APP_ID for a non-positive appId; UNAUTHORIZED when the destination is the reserved sentinel (-6,-6,-6) or the user lacks the app "teleport" runtime permission. */
    errorCode: UdpErrorCode;
    /** True when the teleport is authorized/accepted; false otherwise (inspect errorCode for the reason). */
    success: Scalars['Boolean']['output'];
};
/** One named parameter expression bound into a timer invocation. */
export type TimerParamInput = {
    /** Expression evaluated when the timer is armed (not when it fires), in the arming invocation context. */
    expression: Scalars['String']['input'];
    /** Parameter name on the timer's target function. */
    name: Scalars['String']['input'];
};
export type TransferGridOwnershipInput = {
    /** App that contains the grid. */
    appId: Scalars['BigInt']['input'];
    /** Required when the new tenure is RENTED. */
    expiresAt?: InputMaybe<Scalars['DateTime']['input']>;
    /** Grid whose title transfers. */
    gridId: Scalars['BigInt']['input'];
    /** User id receiving title. */
    newOwnerUserId: Scalars['BigInt']['input'];
    /** New owner tenure. */
    tenure?: InputMaybe<GridTenure>;
};
export type TransferPlayerCodeListingInput = {
    /** Numeric app id that owns the listing. */
    appId: Scalars['BigInt']['input'];
    /** UUID of the listing to transfer. */
    listingId: Scalars['String']['input'];
    /** New owner kind (USER or ORG). */
    toOwnerKind: PlayerCodeOwnerKind;
    /** Numeric user id or org id of the new owner, per toOwnerKind. */
    toOwnerRef: Scalars['BigInt']['input'];
};
/** Error codes returned by UDP game servers (and surfaced on `GenericErrorResponse.errorCode`) in response to a spatial/realtime message. NO_ERROR (0) indicates success; every other value indicates a failure. The numeric value is the byte sent on the wire; GraphQL exposes the name. Note: a failed message does not always produce an error — some auth failures are dropped silently (see the docs). */
export declare enum UdpErrorCode {
    /** No app matches the supplied appId. */
    AppNotFound = "APP_NOT_FOUND",
    /** The app exists but is not currently loaded/active on this server. */
    AppNotLoaded = "APP_NOT_LOADED",
    /** The password did not match (login validation). */
    BadPassword = "BAD_PASSWORD",
    CannotDeleteDefaultWorldGrid = "CANNOT_DELETE_DEFAULT_WORLD_GRID",
    /** No chunk exists at the referenced coordinates. */
    ChunkNotFound = "CHUNK_NOT_FOUND",
    /** Registration failed because the email is already in use. */
    EmailAlreadyExists = "EMAIL_ALREADY_EXISTS",
    /** Email failed format validation. */
    EmailInvalid = "EMAIL_INVALID",
    /** No account matches the supplied email (login validation). */
    EmailNotFound = "EMAIL_NOT_FOUND",
    /** Email failed maximum-length validation. */
    EmailTooLong = "EMAIL_TOO_LONG",
    /** Email failed minimum-length validation. */
    EmailTooShort = "EMAIL_TOO_SHORT",
    /** The requested gamertag is already taken. */
    GamertagAlreadyExists = "GAMERTAG_ALREADY_EXISTS",
    /** The game token is not the expected length. Use the exact token returned by login (do not trim or re-encode it). */
    GameTokenWrongSize = "GAME_TOKEN_WRONG_SIZE",
    /** A grid already exists at these coordinates. */
    GridAlreadyExists = "GRID_ALREADY_EXISTS",
    GridHasNestedChildren = "GRID_HAS_NESTED_CHILDREN",
    GridNotFound = "GRID_NOT_FOUND",
    /** The target coordinates fall outside any grid assigned to the caller. */
    GridOutsideAssignment = "GRID_OUTSIDE_ASSIGNMENT",
    /** The requested grid overlaps an existing grid. */
    GridOverlapsExisting = "GRID_OVERLAPS_EXISTING",
    /** The appId was missing, zero, or not a valid value. */
    InvalidAppId = "INVALID_APP_ID",
    /** The grid coordinates were invalid. */
    InvalidGridCoordinates = "INVALID_GRID_COORDINATES",
    /** The message was malformed or failed validation. Check the byte layout. */
    InvalidRequest = "INVALID_REQUEST",
    /** The state/payload bytes were invalid for this message type. */
    InvalidStateData = "INVALID_STATE_DATA",
    /** The game token was rejected (expired, malformed, or revoked). Re-authenticate against the Management API to obtain a fresh token. */
    InvalidToken = "INVALID_TOKEN",
    /** The supplied token was not a valid length. */
    InvalidTokenLength = "INVALID_TOKEN_LENGTH",
    /** A supplied name exceeded the maximum length. */
    NameTooLong = "NAME_TOO_LONG",
    /** No error (0). The message was accepted. */
    NoError = "NO_ERROR",
    /** No grid assignment covers the referenced coordinates. */
    NoMatchingGridAssignment = "NO_MATCHING_GRID_ASSIGNMENT",
    /** Password failed maximum-length validation. */
    PasswordTooLong = "PASSWORD_TOO_LONG",
    /** Password failed minimum-length validation. */
    PasswordTooShort = "PASSWORD_TOO_SHORT",
    /** The app-scoped gameplay token has expired. Refresh it (same app, via refreshAppToken) before it lapses, or re-portal through the Overworld for a fresh token, then re-authorize the realtime session. */
    TokenExpired = "TOKEN_EXPIRED",
    /** The caller lacks the runtime/grid permission required for this action. Grid permissions can load asynchronously, so the first message to a newly entered region may transiently return this — retry shortly. */
    Unauthorized = "UNAUTHORIZED",
    /** Unspecified server error (1). Retry; if it persists, report it. */
    UnknownError = "UNKNOWN_ERROR",
    /** Requires app-admin privileges (the 'manage_apps' permission). */
    UserNotAppAdmin = "USER_NOT_APP_ADMIN",
    /** This client has no authenticated session on the server. Complete the UDP token handshake (or open the UDP proxy) before sending spatial messages. */
    UserNotAuthenticated = "USER_NOT_AUTHENTICATED"
}
/** All game-server messages delivered over the UDP proxy as GraphQL payloads. Subscribe to udpNotifications before or with sending mutations so responses and GenericErrorResponse (correlate via sequenceNumber) are not missed. NOTE: the ActorUpdateResponse and VoxelUpdateResponse members are LEGACY and never emitted (applied updates arrive as your own *Notification self-echo; failures as GenericErrorResponse) — they remain in the union for backward compatibility and will be removed in a future major version. */
export type UdpNotification = ActorUpdateNotification | ActorUpdateResponse | ChannelMessageNotification | ClientAudioNotification | ClientEventNotification | ClientTextNotification | GenericErrorResponse | RealtimeConnectionEvent | ServerEventNotification | SingleActorMessageNotification | VoxelUpdateNotification | VoxelUpdateResponse;
/** UDP proxy session for the game token on the request. Returned by udpProxyConnectionStatus and connectUdpProxy. Binary UDP layouts are documented in database/client-wire-formats.md. */
export type UdpProxyConnectionStatus = {
    __typename?: 'UdpProxyConnectionStatus';
    /** Whether the user is currently connected to a UDP game server through the proxy. */
    connected: Scalars['Boolean']['output'];
    /** Timestamp of the last message received from the UDP server (only present when connected). Used to detect connection health. */
    lastMessageTime: Maybe<Scalars['DateTime']['output']>;
    /** The client port of the UDP game server (only present when connected). This is the port that native clients would connect to directly. */
    serverClientPort: Maybe<Scalars['Int']['output']>;
    /** The IPv6 address of the UDP game server (only present when connected). */
    serverIp6: Maybe<Scalars['String']['output']>;
};
/** Fields to update on an access tier. All fields are optional; omitted fields are left unchanged. */
export type UpdateAccessTierInput = {
    /** New billing cadence (e.g. "month", "year"); null clears it. */
    billingPeriod?: InputMaybe<Scalars['String']['input']>;
    /** New ISO 4217 currency code (e.g. "usd"). */
    currency?: InputMaybe<Scalars['String']['input']>;
    /** New tier description; null clears it. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Set whether this is the app's default tier. */
    isDefault?: InputMaybe<Scalars['Boolean']['input']>;
    /** Set whether the tier is free. */
    isFree?: InputMaybe<Scalars['Boolean']['input']>;
    /** New tier name (max 128 chars). */
    name?: InputMaybe<Scalars['String']['input']>;
    /** External PayPal plan id to associate (billing integration). */
    paypalPlanId?: InputMaybe<Scalars['String']['input']>;
    /** Replacement set of runtime permission keys for the tier (must be valid runtimePermissions). When provided, replaces the existing set entirely. */
    permissionKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    /** New price in cents; null clears the price (makes the tier unpriced). */
    priceCents?: InputMaybe<Scalars['BigInt']['input']>;
    /** External Stripe price id to associate (billing integration). */
    stripePriceId?: InputMaybe<Scalars['String']['input']>;
    /** New sort order (ascending). */
    tierOrder?: InputMaybe<Scalars['Int']['input']>;
};
export type UpdateActorInput = {
    /** New app id, or omit to leave unchanged. BigInt sent as a decimal string. */
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    /** New avatar id, or omit to leave unchanged. BigInt sent as a decimal string. */
    avatarId?: InputMaybe<Scalars['BigInt']['input']>;
    /** New chunk-grid coordinates (x, y, z as int64 BigInt decimal strings), or omit to leave unchanged. */
    chunk?: InputMaybe<ChunkCoordinatesInput>;
    /** New owner-only private state blob (base64-encoded binary), or omit to leave unchanged. */
    privateState?: InputMaybe<Scalars['String']['input']>;
    /** New public state blob (base64-encoded binary), or omit to leave unchanged. */
    publicState?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateActorStateInput = {
    /** New owner-only private state blob (base64-encoded binary), or omit to leave unchanged. */
    privateState?: InputMaybe<Scalars['String']['input']>;
    /** New public state blob (base64-encoded binary), or omit to leave unchanged. */
    publicState?: InputMaybe<Scalars['String']['input']>;
};
/** Input payload for updating an app. All fields are optional; only fields that are provided are changed. */
export type UpdateAppInput = {
    /** New short description. Omit to leave unchanged. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** New JSON-encoded marketplace metadata string, replacing the existing value (see App.metadata). Omit to leave unchanged. */
    metadata?: InputMaybe<Scalars['String']['input']>;
    /** New display name (1-256 chars). Omit to leave unchanged. */
    name?: InputMaybe<Scalars['String']['input']>;
    /** New lifecycle status; set LIVE to publish, or DRAFT/LIVE to restore an archived app. Omit to leave unchanged. */
    status?: InputMaybe<AppStatus>;
    /** New visibility (PUBLIC/UNLISTED/PRIVATE). Omit to leave unchanged. */
    visibility?: InputMaybe<AppVisibility>;
};
export type UpdateAvatarAppStateInput = {
    /** App (game) id the state is scoped to. Required. BigInt sent as a decimal string. */
    appId: Scalars['BigInt']['input'];
    /** Avatar whose per-app state to write; must be owned by the caller. Required. BigInt sent as a decimal string. */
    avatarId: Scalars['BigInt']['input'];
    /** Per-app avatar state as base64-encoded binary. Send null (or omit) to clear it. */
    state?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateAvatarInput = {
    /** New avatar name, or omit to leave unchanged. */
    name?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateAvatarStateInput = {
    /** New owner-only private state blob (base64-encoded binary), or omit to leave unchanged. */
    privateState?: InputMaybe<Scalars['String']['input']>;
    /** New public state blob (base64-encoded binary), or omit to leave unchanged. */
    publicState?: InputMaybe<Scalars['String']['input']>;
};
/** Update an existing channel. Omitted fields are left unchanged. */
export type UpdateChannelInput = {
    /** New description. Omit to leave unchanged. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** The channel (group) id to update. */
    groupId: Scalars['BigInt']['input'];
    /** open | request | invite | admin. Omit to leave unchanged. */
    membershipPolicy?: InputMaybe<Scalars['String']['input']>;
    /** New channel name (max 128 chars). Omit to leave unchanged. */
    name?: InputMaybe<Scalars['String']['input']>;
};
/** Payload for updateChunkLods: replaces the chunk's entire LOD set. Only LODs are written; voxels, voxel states, chunk state and owner are preserved. */
export type UpdateChunkLodsInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk whose LODs to replace. */
    coordinates: ChunkCoordinatesInput;
    /** Full set of LOD levels to store for the chunk; this REPLACES any existing LODs. */
    lods: Array<LodDataInput>;
};
/** Payload for updateChunkState: upserts ONLY the chunk-level opaque state blob; the voxel grid, per-voxel states and LODs are preserved. */
export type UpdateChunkStateInput = {
    /** Id of the app that owns the chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** BASE64-encoded binary chunk-level state blob to store. Omit/null to store no chunk state. */
    chunkState?: InputMaybe<Scalars['String']['input']>;
    /** Address of the chunk whose chunk-level state to set. */
    coordinates: ChunkCoordinatesInput;
};
export type UpdateGamertagInput = {
    /** Discriminator paired with `gamertag` (max 128 characters) to form a unique handle. */
    disambiguation: Scalars['String']['input'];
    /** New gamertag (max 64 characters). Must be unique in combination with `disambiguation`. */
    gamertag: Scalars['String']['input'];
};
/** Update a custom group role. Omitted fields are left unchanged. */
export type UpdateGroupRoleInput = {
    /** The group role id to update. */
    groupRoleId: Scalars['BigInt']['input'];
    /** When provided, REPLACES the role's permission key strings. Each must be a valid group permission key for the group type (max 64 chars, unique). Omit to leave permissions unchanged. */
    permissions?: InputMaybe<Array<Scalars['String']['input']>>;
    /** New rank (higher = more senior). Ignored for system roles. Omit to leave unchanged. */
    rank?: InputMaybe<Scalars['Int']['input']>;
    /** New role name (max 128 chars). Ignored for system roles. Omit to leave unchanged. */
    roleName?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateOrgRoleInput = {
    /** New description; omit to leave unchanged. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** If provided, replaces the entire permission set (empty array clears all); omit to leave unchanged. */
    permissions?: InputMaybe<Array<Scalars['String']['input']>>;
    /** New role name; omit to leave unchanged. */
    roleName?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateOrgTokenInput = {
    /** New expiry timestamp; omit to leave unchanged. */
    expiresAt?: InputMaybe<Scalars['DateTime']['input']>;
    /** Set false to deactivate the token; omit to leave unchanged. Revoked tokens cannot be re-minted. */
    isActive?: InputMaybe<Scalars['Boolean']['input']>;
    /** New label; omit to leave unchanged. */
    label?: InputMaybe<Scalars['String']['input']>;
};
/** Update an existing team. Omitted fields are left unchanged. */
export type UpdateTeamInput = {
    /** New description. Omit to leave unchanged. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** The team (group) id to update. */
    groupId: Scalars['BigInt']['input'];
    /** open | request | invite | admin. Omit to leave unchanged. */
    membershipPolicy?: InputMaybe<Scalars['String']['input']>;
    /** New team name (max 128 chars). Omit to leave unchanged. */
    name?: InputMaybe<Scalars['String']['input']>;
};
export type UpdateUserStateInput = {
    /** New user-level state blob, base64-encoded binary, at most 1,048,576 base64 characters (~768 KiB binary); larger payloads draw a structured validation error. Omit or send null to clear it. */
    state?: InputMaybe<Scalars['String']['input']>;
};
/** Payload for updateVoxel: records (upserts) a single voxel edit in the voxel_updates log for one chunk. */
export type UpdateVoxelInput = {
    /** Id of the app that owns the target chunk (decimal string). */
    appId: Scalars['BigInt']['input'];
    /** Address of the chunk that contains the voxel to edit. */
    coordinates: ChunkCoordinatesInput;
    /** Local voxel position within the chunk (0-15 per axis; validated to the signed 16-bit range). */
    location: VoxelCoordinatesInput;
    /** Optional BASE64-encoded binary state blob for the voxel; omit for none. */
    state?: InputMaybe<Scalars['String']['input']>;
    /** Voxel type id to write (0-255). */
    voxelType: Scalars['Float']['input'];
};
/** Create or update an autonomous process (automation / NPC). Upsert key is (app, name). */
export type UpsertAutomationInput = {
    /** Action kind: model_function (default — invoke a Model function) or compute_invoke (invoke a compute-module export directly; the trusted server path, no invoke policy evaluation). */
    actionKind?: InputMaybe<Scalars['String']['input']>;
    /** The app (tenant) that owns the automation. */
    appId: Scalars['BigInt']['input'];
    /** For action_kind=compute_invoke: the module invoke export to call (must be bound as an invoke trigger on the module). */
    computeExport?: InputMaybe<Scalars['String']['input']>;
    /** For action_kind=compute_invoke: the compute module name to invoke. */
    computeModuleName?: InputMaybe<Scalars['String']['input']>;
    /** Cooldown (ms) while the circuit is open. */
    cooldownMs?: InputMaybe<Scalars['Int']['input']>;
    /** Cron expression (schedule_kind=cron). */
    cronExpr?: InputMaybe<Scalars['String']['input']>;
    /** Optional description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Whether it may run. Defaults to true. */
    enabled?: InputMaybe<Scalars['Boolean']['input']>;
    /** Consecutive failures that open the circuit. */
    failureThreshold?: InputMaybe<Scalars['Int']['input']>;
    /** Entry-point function name (must be autonomous_invocable). Required for action_kind=model_function; ignored for compute_invoke. */
    functionName?: InputMaybe<Scalars['String']['input']>;
    /** Override: gas per invoke. */
    gasLimit?: InputMaybe<Scalars['Int']['input']>;
    /** Interval in ms (schedule_kind=interval). */
    intervalMs?: InputMaybe<Scalars['Int']['input']>;
    /** Override: max fn: depth per invoke. */
    maxFnDepth?: InputMaybe<Scalars['Int']['input']>;
    /** Max runs per minute for this automation. */
    maxRunsPerMinute?: InputMaybe<Scalars['Int']['input']>;
    /** Max fan-out targets per run. */
    maxTargets?: InputMaybe<Scalars['Int']['input']>;
    /** Automation name (unique per app). The upsert key. */
    name: Scalars['String']['input'];
    /** JSON object of static params. */
    paramsJson?: InputMaybe<Scalars['String']['input']>;
    /** Identity to act as (drives owner_of_self / $caller_user_id). Null = trusted server caller. */
    runAsUserId?: InputMaybe<Scalars['BigInt']['input']>;
    /** Override: wall-clock budget per invoke (ms). */
    runTimeoutMs?: InputMaybe<Scalars['Int']['input']>;
    /** For schedule triggers: interval | cron. */
    scheduleKind?: InputMaybe<Scalars['String']['input']>;
    /** JSON selector resolving candidate refs/scalars over model data into params (e.g. {"pick":"nearest","ofType":"Unit","where":[...],"by":"manhattan","bindAs":{...}}). Also supports grid-permission filters "selfPermissionWhere"/"candidatePermissionWhere": arrays of {"userFrom":"owner"|{"property":k},"op":"has"|"lacks","key":<runtime permission key>,"grid":<id>|{"property":k}} checked against the live grid ACL (omit "grid" for any-grid). */
    selectorJson?: InputMaybe<Scalars['String']['input']>;
    /** For target_mode=container: the self container UUID. */
    selfContainerId?: InputMaybe<Scalars['String']['input']>;
    /** Optional session scope (UUID). */
    sessionId?: InputMaybe<Scalars['String']['input']>;
    /** Target mode: container | type | global. Defaults to container (model_function) / global (compute_invoke). */
    targetMode?: InputMaybe<Scalars['String']['input']>;
    /** For target_mode=type: the container type to fan out over. */
    targetTypeName?: InputMaybe<Scalars['String']['input']>;
    /** Trigger type: schedule | event | manual. Defaults to schedule. */
    triggerType?: InputMaybe<Scalars['String']['input']>;
};
/** Create an event trigger that fires an automation on model activity or a complete app-scoped active-player-count transition. */
export type UpsertAutomationTriggerInput = {
    /** The app (tenant). */
    appId: Scalars['BigInt']['input'];
    /** The automation (by name) this trigger fires. */
    automationName: Scalars['String']['input'];
    /** Filter: only this container type. For function_invoked this is the type of the invocation's "self" container, so you can watch "this function, on this type". Rejected for player_count_changed. */
    containerTypeName?: InputMaybe<Scalars['String']['input']>;
    /** Debounce window in ms. player_count_changed uses trailing-edge coalescing (first previous count plus latest current count/revision); existing model events retain leading-edge suppression. */
    debounceMs?: InputMaybe<Scalars['Int']['input']>;
    /** Filter: only this function name. Applies to function_invoked; rejected for property_changed, container_created, and player_count_changed. */
    functionName?: InputMaybe<Scalars['String']['input']>;
    /** Event to observe: function_invoked | property_changed | container_created | player_count_changed. player_count_changed fires only after complete fleet counts change, and injects reserved previous/current/delta/revision params. */
    onEvent: Scalars['String']['input'];
    /** Filter: only this property key. Applies to property_changed; rejected for function_invoked, container_created, and player_count_changed. */
    propertyKey?: InputMaybe<Scalars['String']['input']>;
    /** property_changed only: which writes to observe — "direct" (gameModelSetProperty), "function" (a mutation applied inside a gameModelInvoke, automation run, or timer fire), or "any" (default). Rejected for other events. */
    writeSource?: InputMaybe<Scalars['String']['input']>;
};
/** Create or update a WASM compute module (metadata only; source is uploaded with computeDeployVersion). Upsert key is (app, name). */
export type UpsertComputeModuleInput = {
    /** Run without active players (world simulation). Policy-gated; defaults to false. */
    alwaysOn?: InputMaybe<Scalars['Boolean']['input']>;
    /** The app (tenant) that owns the module. */
    appId: Scalars['BigInt']['input'];
    /** Optional description. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Module name (unique per app, lowercase crate-style: [a-z][a-z0-9_-]*). The upsert key. */
    name: Scalars['String']['input'];
};
/** Bind a trigger to a module: a tick loop (tick_hz), a model/compute event subscription, or a client-invokable export. */
export type UpsertComputeTriggerInput = {
    /** The app (tenant). */
    appId: Scalars['BigInt']['input'];
    /** Event filter: only this container type. */
    containerTypeName?: InputMaybe<Scalars['String']['input']>;
    /** For invoke triggers: optional typed contract (JSON): {"params": {name: {type, required?, description?}}, "result": {...}, "description"?}. Types: int|float|string|bool|object|array. Declared params are validated on computeInvoke BEFORE the sandbox runs (required presence + type; undeclared params pass through); result is documentation/codegen only. Null = no validation. */
    contractJson?: InputMaybe<Scalars['String']['input']>;
    /** Debounce/coalesce window in ms for event triggers. */
    debounceMs?: InputMaybe<Scalars['Int']['input']>;
    /** Event filter: only compute events with this name (on_event=compute_event). */
    eventName?: InputMaybe<Scalars['String']['input']>;
    /** For invoke triggers: the exported guest function name computeInvoke routes to. */
    exportName?: InputMaybe<Scalars['String']['input']>;
    /** Event filter: only this model function name. */
    functionName?: InputMaybe<Scalars['String']['input']>;
    /** For invoke triggers: JSON authority tree gating who may invoke (same shape as game-model function invoke policies). Null = app admins only. */
    invokePolicyJson?: InputMaybe<Scalars['String']['input']>;
    /** The module (by name) this trigger drives. */
    moduleName: Scalars['String']['input'];
    /** For event triggers: function_invoked | property_changed | container_created | compute_event. */
    onEvent?: InputMaybe<Scalars['String']['input']>;
    /** Event filter: only this property key. */
    propertyKey?: InputMaybe<Scalars['String']['input']>;
    /** For tick triggers: the tick rate in Hz (clamped by the app policy's maxTickHz). */
    tickHz?: InputMaybe<Scalars['Float']['input']>;
    /** Trigger type: tick | event | invoke. */
    triggerType: Scalars['String']['input'];
};
/** Create or update a container type (schema for a kind of entity). */
export type UpsertContainerTypeInput = {
    /** The app (tenant) that owns the type. */
    appId: Scalars['BigInt']['input'];
    /** Who may CREATE a container of this type under a client-supplied bindingKey (gameModelEnsureContainer). Same JSON shape as a function invokePolicyJson — an AuthorityRule tree — except that owner_of_self, is_current_turn and condition are refused, because a bind creates the container and there is no acting container to resolve them against. Omit it (the default) and binding is governed by the type's instantiableBy alone, which is the behaviour before this field existed. Resolving an EXISTING key is unaffected: it is a read. For a shared world object, {"type":"is_host"} or instantiableBy: admin stops one player from squatting the key and becoming its owner. */
    bindPolicyJson?: InputMaybe<Scalars['String']['input']>;
    /** public | owner | hidden default for this type's properties. */
    defaultPropertyVisibility?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the type. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Human-friendly display name. */
    displayName: Scalars['String']['input'];
    /** admin | member | owner (who may instantiate this type). */
    instantiableBy?: InputMaybe<Scalars['String']['input']>;
    /** JSON object of metadata. */
    metadataJson?: InputMaybe<Scalars['String']['input']>;
    /** Stable type name (unique per app). Acts as the upsert key. */
    typeName: Scalars['String']['input'];
};
/** Create or update a studio-defined function. Upsert key is (app, name). */
export type UpsertFunctionInput = {
    /** The app (tenant) that owns the function. */
    appId: Scalars['BigInt']['input'];
    /** Opt-in: allow an autonomous process (automation/NPC) to use this function as an entry point. Defaults to false. Players are unaffected; this only enables server-driven invocation. */
    autonomousInvocable?: InputMaybe<Scalars['Boolean']['input']>;
    /** Optional container type to bind the function to (omit for a global function). */
    containerTypeName?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the function. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** JSON-encoded invoke-policy rule tree (authority requirements). */
    invokePolicyJson?: InputMaybe<Scalars['String']['input']>;
    /** player | server | internal */
    invokeScope?: InputMaybe<Scalars['String']['input']>;
    /** The property writes the function performs (applied atomically when invoked). */
    mutations?: InputMaybe<Array<FunctionMutationInput>>;
    /** Function name (unique per app). Used to invoke it. */
    name: Scalars['String']['input'];
    /** Declarative realtime notifications the function emits via Buddy AFTER it commits. Players and automations (NPCs) emit identically; fenced by delivery mode. */
    notifications?: InputMaybe<Array<FunctionNotificationInput>>;
    /** Typed parameters the function accepts. */
    parameters?: InputMaybe<Array<FunctionParamInput>>;
    /** Declarative grid-permission effects (grant/revoke runtime grid ACL rows) applied atomically with the function's mutations. Max 4 per function. */
    permissionEffects?: InputMaybe<Array<FunctionPermissionEffectInput>>;
    /** Optional expression whose value becomes the invoke result. */
    returnExpression?: InputMaybe<Scalars['String']['input']>;
    /** Optional declared return value type. */
    returnType?: InputMaybe<Scalars['String']['input']>;
    /** Declarative one-shot timers armed atomically with the function's mutations: invoke another function after a delay. Max 4 per function. */
    timers?: InputMaybe<Array<FunctionTimerInput>>;
};
/** Create or update a typed property on a container type. */
export type UpsertPropertyDefInput = {
    /** The app (tenant) that owns the type. */
    appId: Scalars['BigInt']['input'];
    /** The container type to define the property on. */
    containerTypeName: Scalars['String']['input'];
    /** JSON-encoded default value. */
    defaultValueJson?: InputMaybe<Scalars['String']['input']>;
    /** Optional description of the property. */
    description?: InputMaybe<Scalars['String']['input']>;
    /** Property key (unique within the type). Part of the upsert key. */
    key: Scalars['String']['input'];
    /** int | float | string | bool | array | object | container_ref */
    valueType: Scalars['String']['input'];
    /** public | owner | hidden */
    visibility?: InputMaybe<Scalars['String']['input']>;
    /** function | owner | admin */
    writable?: InputMaybe<Scalars['String']['input']>;
};
/** One minute-bucketed usage sample. Byte/message counters are returned as strings because they can exceed the 32-bit Int range. */
export type UsageMinuteRow = {
    __typename?: 'UsageMinuteRow';
    /** Start of the one-minute bucket. */
    minute: Scalars['DateTime']['output'];
    /** Bytes received in the minute (string counter). */
    recvBytes: Scalars['String']['output'];
    /** Messages received in the minute (replication only). */
    recvMsgs: Maybe<Scalars['String']['output']>;
    /** Bytes sent in the minute (string counter). */
    sendBytes: Scalars['String']['output'];
    /** Messages sent in the minute (replication only). */
    sendMsgs: Maybe<Scalars['String']['output']>;
};
/** Peak and average send rates over the sampled replication window. */
export type UsageRatePeaks = {
    __typename?: 'UsageRatePeaks';
    /** Average sent megabits per second over the window. */
    avgSendMbitPerSec: Scalars['Float']['output'];
    /** Average sent messages per second over the window. */
    avgSendMsgsPerSec: Scalars['Float']['output'];
    /** Highest observed sent megabits per second. */
    peakSendMbitPerSec: Scalars['Float']['output'];
    /** Highest observed sent messages per second. */
    peakSendMsgsPerSec: Scalars['Float']['output'];
    /** Number of minute samples the averages are computed over. */
    sampleMinutes: Scalars['Float']['output'];
};
export type User = {
    __typename?: 'User';
    /** Account creation timestamp (ISO-8601). */
    createdAt: Scalars['DateTime']['output'];
    /** Discriminator paired with `gamertag` to form a unique handle; null if unset. */
    disambiguation: Maybe<Scalars['String']['output']>;
    /** Account email; null for anonymized/soft-deleted accounts. */
    email: Maybe<Scalars['String']['output']>;
    /** External identity-provider id for federated accounts, or null. */
    externalId: Maybe<Scalars['String']['output']>;
    /** Public display name; null if unset or anonymized. Unique in combination with `disambiguation`. */
    gamertag: Maybe<Scalars['String']['output']>;
    /** Whether the user qualifies for early access through normal eligibility (the free-play window/rollout). */
    grantEarlyAccess: Scalars['Boolean']['output'];
    /** Admin override forcing early access on/off regardless of normal eligibility (set via `setEarlyAccessOverride`). */
    grantEarlyAccessOverride: Scalars['Boolean']['output'];
    /** Whether the account email has been confirmed. */
    isConfirmed: Scalars['Boolean']['output'];
    /** Company-employee flag that grants access to control-plane / operator features. Independent from is_super_admin. */
    isOperator: Scalars['Boolean']['output'];
    /** Whether the user holds platform super-admin privileges (toggled via `setSuperAdmin`). */
    isSuperAdmin: Scalars['Boolean']['output'];
    /** Organization the user belongs to, or null. BigInt serialized as a decimal string. */
    orgId: Maybe<Scalars['BigInt']['output']>;
    /** The user's effective permission keys on the given org (empty if not a member; full set if super admin). Requires a valid bearer game token. */
    permissionsForOrg: Array<Scalars['String']['output']>;
    /** User-level state blob, base64-encoded binary (management-owned). Null when cleared. */
    state: Maybe<Scalars['String']['output']>;
    /** Unique user id and primary key. BigInt serialized as a decimal string. */
    userId: Scalars['BigInt']['output'];
    /** Account type, e.g. "direct" or "deleted". */
    userType: Scalars['String']['output'];
};
export type UserPermissionsForOrgArgs = {
    orgId: Scalars['BigInt']['input'];
};
export type UserAppState = {
    __typename?: 'UserAppState';
    /** App (game) id this state is scoped to. BigInt serialized as a decimal string. */
    appId: Scalars['BigInt']['output'];
    /** Row creation timestamp (ISO-8601). */
    createdAt: Scalars['DateTime']['output'];
    /** Per-app user state blob, base64-encoded binary; null when cleared. */
    state: Maybe<Scalars['String']['output']>;
    /** Last-update timestamp (ISO-8601). */
    updatedAt: Scalars['DateTime']['output'];
    /** Owner user id. BigInt serialized as a decimal string. */
    userId: Scalars['BigInt']['output'];
};
/** Whose problem a failure is. The platform attributes blame; the game decides what to render. PLATFORM means ours and a retry is reasonable; AUTHOR means the app's own code and the same call will fail the same way; BUDGET means an allowance is spent and nothing is broken. */
export declare enum UserCodeFaultBlame {
    /** The app's own code or configuration. Repeating the call gets the same answer. */
    Author = "AUTHOR",
    /** A metered allowance for this app or caller is spent. Nothing is broken. */
    Budget = "BUDGET",
    /** Ours. The app's code is not at fault — it may not have run at all. */
    Platform = "PLATFORM"
}
/** Which engine ran the code that faulted: the model expression engine, studio WASM compute, or player WASM compute. */
export declare enum UserCodeFaultEngine {
    /** The model expression engine: declarative JSON ASTs bounded by gas and a wall-clock deadline. */
    Expression = "EXPRESSION",
    /** Player WASM compute: the same compiler and sandbox at a lower trust tier, owned by a player. */
    PlayerWasm = "PLAYER_WASM",
    /** Studio WASM compute: Rust compiled by the pinned toolchain and run in a worker-thread sandbox. */
    StudioWasm = "STUDIO_WASM"
}
/** What went wrong, at the granularity an operator would alert on and a developer would fix. One kind per distinguishable remedy: an expression timeout and a watchdog termination are both "ran too long" and are kept apart because one rolls back a transaction and the other kills a worker thread. */
export declare enum UserCodeFaultKind {
    BindingMismatch = "BINDING_MISMATCH",
    CallLimitExceeded = "CALL_LIMIT_EXCEEDED",
    CircuitOpen = "CIRCUIT_OPEN",
    ContractValidationFailed = "CONTRACT_VALIDATION_FAILED",
    DbOpsExceeded = "DB_OPS_EXCEEDED",
    DisabledByPolicy = "DISABLED_BY_POLICY",
    EgressBudgetExceeded = "EGRESS_BUDGET_EXCEEDED",
    ExpressionError = "EXPRESSION_ERROR",
    ExpressionTimeout = "EXPRESSION_TIMEOUT",
    FuelExhausted = "FUEL_EXHAUSTED",
    GasExhausted = "GAS_EXHAUSTED",
    HostCallFailed = "HOST_CALL_FAILED",
    InternalError = "INTERNAL_ERROR",
    MemoryExceeded = "MEMORY_EXCEEDED",
    ModuleLoadFailed = "MODULE_LOAD_FAILED",
    PlatformBusy = "PLATFORM_BUSY",
    QuotaExhausted = "QUOTA_EXHAUSTED",
    RateLimitExceeded = "RATE_LIMIT_EXCEEDED",
    ResponseTooLarge = "RESPONSE_TOO_LARGE",
    SandboxPoisoned = "SANDBOX_POISONED",
    StateWriteBudgetExceeded = "STATE_WRITE_BUDGET_EXCEEDED",
    UnknownHostFunction = "UNKNOWN_HOST_FUNCTION",
    WasmTrap = "WASM_TRAP",
    WatchdogTerminated = "WATCHDOG_TERMINATED",
    WorkerExit = "WORKER_EXIT"
}
/** One failure of code a user wrote, from any of the three engines. Replaces three disagreeing surfaces: a bare error string on the invoke path, a run table that recorded failures and not successes, and a last_error slot the next success cleared. */
export type UserCodeFaultRecord = {
    __typename?: 'UserCodeFaultRecord';
    /** The user the work ran on behalf of, when there was one. */
    actingUserId: Maybe<Scalars['BigInt']['output']>;
    /** The app (tenant) the fault occurred in. */
    appId: Scalars['BigInt']['output'];
    /** Whose problem this is. Stored rather than derived from kind, because the same kind can have a different owner given context — which is what platform saturation reported as an author timeout cost us. */
    blame: UserCodeFaultBlame;
    /** The wall-clock budget it was given, in microseconds. Stored beside durationUs rather than as a ratio: 249ms against a 250ms budget and 249ms against a 2000ms budget are different bugs. */
    budgetUs: Maybe<Scalars['String']['output']>;
    /** Operator-facing detail, for the developer who owns the app. Never shown to a player. */
    detail: Maybe<Scalars['String']['output']>;
    /** Wall-clock microseconds the work consumed before it faulted. */
    durationUs: Maybe<Scalars['String']['output']>;
    /** Which engine ran the code. */
    engine: UserCodeFaultEngine;
    /** The entry point that started the work: player_invoke, automation, system, tick, invoke, event, init. */
    entryPoint: Maybe<Scalars['String']['output']>;
    /** Unique fault id. */
    faultId: Scalars['String']['output'];
    /** Correlation id shared with gm_event_log, gm_automation_runs and wasm_module_runs; pass it to gameModelFlow for the whole timeline. */
    flowId: Maybe<Scalars['String']['output']>;
    /** The grid, when the faulting code belonged to one (player WASM). */
    gridId: Maybe<Scalars['BigInt']['output']>;
    /** Which ck-api instance observed the fault. A fault that only ever appears on one instance is a different bug from one the fleet shares. */
    instanceId: Maybe<Scalars['String']['output']>;
    /** What went wrong. */
    kind: UserCodeFaultKind;
    /** When the fault was recorded. */
    occurredAt: Scalars['DateTime']['output'];
    /** Whether repeating the identical call could succeed with nothing else changing. This is what a game reads to choose between retrying and telling the player it is broken. */
    retryable: Scalars['Boolean']['output'];
    /** Mutation steps or host calls completed before the fault. This is what distinguishes "never started" from "died on step nine". */
    stepsCompleted: Maybe<Scalars['Int']['output']>;
    /** What ran: the function name for the expression engine, the module name for either WASM engine. */
    subject: Scalars['String']['output'];
    /** Budget units granted, in the same units as unitsUsed. */
    unitsLimit: Maybe<Scalars['String']['output']>;
    /** Budget units consumed — expression-engine gas or WASM fuel. Named neutrally so a developer using both engines can compare them. */
    unitsUsed: Maybe<Scalars['String']['output']>;
};
/** Faults grouped by engine, kind and blame over a window — the shape to alert on, and the answer to "is this us or them". */
export type UserCodeFaultSummaryEntry = {
    __typename?: 'UserCodeFaultSummaryEntry';
    /** Whose problem it is. */
    blame: UserCodeFaultBlame;
    /** Which engine. */
    engine: UserCodeFaultEngine;
    /** How many faults of this shape in the window. */
    faults: Scalars['Int']['output'];
    /** What went wrong. */
    kind: UserCodeFaultKind;
    /** The most recent one. */
    lastAt: Scalars['DateTime']['output'];
    /** What ran. */
    subject: Scalars['String']['output'];
};
export type UserDonationData = {
    __typename?: 'UserDonationData';
    /** ISO currency code for the total, e.g. "usd". */
    currency: Scalars['String']['output'];
    /** Lifetime donation total in minor currency units (cents), as a decimal string. */
    totalAmountCents: Scalars['String']['output'];
};
/** An edge in a User connection. */
export type UserEdge = {
    __typename?: 'UserEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: User;
};
/** A sign-in identity linked to a user account: a social provider, an emailed magic link, or a password. */
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) | 'password'. 'dev' is a RETIRED value that appears on identities created before the dev sign-in bypass was removed; it cannot be created and cannot be signed in with. */
    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'];
};
export type UserPropertyTokenData = {
    __typename?: 'UserPropertyTokenData';
    /** Property tokens currently available, as a decimal string. */
    available: Scalars['String']['output'];
    /** Property tokens currently in use, as a decimal string. */
    inUse: Scalars['String']['output'];
    /** Sum of available + inUse, as a decimal string. */
    total: Scalars['String']['output'];
};
/** A Relay cursor connection over User records. Page with first/after; pass pageInfo.endCursor back as after for the next page. */
export type UsersConnection = {
    __typename?: 'UsersConnection';
    /** Edges on this page. */
    edges: Array<UserEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
export type UsersPage = {
    __typename?: 'UsersPage';
    /** Users on the current page, ordered by ascending user id. */
    items: Array<User>;
    /** Pagination metadata: totalCount, applied limit, and applied offset. */
    pageInfo: PageInfo;
};
/** A semantic-style version as four integer components (major.minor.patch.build). Compare components in order (major, then minor, then patch, then build). */
export type VersionInfo = {
    __typename?: 'VersionInfo';
    /** Build number */
    build: Scalars['Int']['output'];
    /** Major version number */
    major: Scalars['Int']['output'];
    /** Minor version number */
    minor: Scalars['Int']['output'];
    /** Patch version number */
    patch: Scalars['Int']['output'];
};
/** A recorded edit to a single voxel (one row of the voxel_updates log): the app/chunk/local-position that changed, the new voxel type, an optional state blob, and who/when. Returned by listVoxels, getVoxelList and listVoxelUpdatesByDistance; created by updateVoxel. A background maintenance job later folds these edits into the chunk grid. */
export type Voxel = {
    __typename?: 'Voxel';
    /** Id of the app this edit belongs to (decimal string). */
    appId: Scalars['BigInt']['output'];
    /** Address of the chunk that contains the edited voxel. */
    coordinates: ChunkCoordinates;
    /** When the edit was recorded; also serves as the last-modified time for the voxel. */
    createdAt: Scalars['DateTime']['output'];
    /** Id of the user that made this edit (decimal string). */
    createdBy: Scalars['BigInt']['output'];
    /** Local position of the edited voxel within its chunk (0-15 per axis). */
    location: VoxelCoordinates;
    /** BASE64-encoded binary state blob for the voxel (decode from base64); null when no state was set. */
    state: Maybe<Scalars['String']['output']>;
    /** New voxel type id written by this edit (0-255). */
    voxelType: Scalars['Int']['output'];
    /** Unique id of this voxel-update row (decimal string). */
    voxelUpdateId: Scalars['BigInt']['output'];
};
/** Integer (x, y, z) position of a single voxel LOCAL to its chunk (not a world position). Stored as signed 16-bit smallints (-32,768..32,767), but a chunk is 16x16x16 = 4096 voxels, so valid in-bounds positions are 0-15 on each axis. */
export type VoxelCoordinates = {
    __typename?: 'VoxelCoordinates';
    /** Local voxel X within the chunk (0-15 for in-bounds voxels). */
    x: Scalars['Int']['output'];
    /** Local voxel Y within the chunk (0-15 for in-bounds voxels). */
    y: Scalars['Int']['output'];
    /** Local voxel Z within the chunk (0-15 for in-bounds voxels). */
    z: Scalars['Int']['output'];
};
/** Input form of a voxel position LOCAL to its chunk (see VoxelCoordinates). Signed 16-bit integers; in-bounds positions are 0-15 on each axis for a 16x16x16 chunk. */
export type VoxelCoordinatesInput = {
    /** Local voxel X within the chunk (0-15 for in-bounds voxels). */
    x: Scalars['Int']['input'];
    /** Local voxel Y within the chunk (0-15 for in-bounds voxels). */
    y: Scalars['Int']['input'];
    /** Local voxel Z within the chunk (0-15 for in-bounds voxels). */
    z: Scalars['Int']['input'];
};
/** A single voxel's state override stored on a chunk: its local position, its voxel type, and an opaque base64-encoded state blob. */
export type VoxelState = {
    __typename?: 'VoxelState';
    /** BASE64-encoded binary state blob for this voxel (decode from base64); null/empty when the voxel has no extra state. */
    state: Maybe<Scalars['String']['output']>;
    /** Local voxel position within the chunk (0-15 per axis). */
    voxelCoord: VoxelCoordinates;
    /** Voxel type id at this position (0-255). */
    voxelType: Scalars['Int']['output'];
};
/** One per-voxel state entry to write to a chunk. */
export type VoxelStateInput = {
    /** BASE64-encoded binary state blob for this voxel; omit/null for no extra state. */
    state?: InputMaybe<Scalars['String']['input']>;
    /** Local voxel position within the chunk (0-15 per axis). */
    voxelCoord: VoxelCoordinatesInput;
    /** Voxel type id to set at this position (0-255). */
    voxelType: Scalars['Int']['input'];
};
/** Relay-style cursor-paginated connection over voxel edit history entries (VoxelUpdateHistoryEvent). Page with `first`/`after`; cursors are opaque. */
export type VoxelUpdateHistoryConnection = {
    __typename?: 'VoxelUpdateHistoryConnection';
    /** Edges on this page. */
    edges: Array<VoxelUpdateHistoryEventEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** One entry in the immutable voxel edit history (voxel_updates_history): a recorded change of a single voxel's type, with who and when. Returned by voxelUpdateHistory, newest first. */
export type VoxelUpdateHistoryEvent = {
    __typename?: 'VoxelUpdateHistoryEvent';
    /** Id of the app this change belongs to (decimal string). */
    appId: Scalars['BigInt']['output'];
    /** Timestamp when the change occurred. */
    changedAt: Scalars['DateTime']['output'];
    /** Id of the user that made the change (decimal string), or null if unknown. */
    changedBy: Maybe<Scalars['BigInt']['output']>;
    /** Address of the chunk that contains the changed voxel. */
    coordinates: ChunkCoordinates;
    /** Unique id of this history entry (decimal string). */
    id: Scalars['BigInt']['output'];
    /** Local position of the changed voxel within its chunk. */
    location: VoxelCoordinates;
    /** Voxel type after the change, or null if the voxel was cleared/removed. */
    newVoxelType: Maybe<Scalars['Int']['output']>;
    /** Voxel type before the change, or null if the voxel did not previously exist. */
    oldVoxelType: Maybe<Scalars['Int']['output']>;
};
/** An edge in a VoxelUpdateHistoryEvent connection. */
export type VoxelUpdateHistoryEventEdge = {
    __typename?: 'VoxelUpdateHistoryEventEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: VoxelUpdateHistoryEvent;
};
/** Notification received when a voxel (block) is updated by another client or the server. Received via the udpNotifications subscription. */
export type VoxelUpdateNotification = {
    __typename?: 'VoxelUpdateNotification';
    /** The ID of the app where the voxel is located. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk containing the voxel. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk containing the voxel. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk containing the voxel. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The sender's sequence number for this message (0-255). */
    sequenceNumber: Scalars['Int']['output'];
    /** The unique identifier for this voxel update. */
    uuid: Scalars['String']['output'];
    /** The voxel state data, base64-encoded. */
    voxelState: Scalars['String']['output'];
    /** The voxel type ID that was set. */
    voxelType: Scalars['Int']['output'];
    /** The X coordinate of the voxel within the chunk. */
    voxelX: Scalars['Int']['output'];
    /** The Y coordinate of the voxel within the chunk. */
    voxelY: Scalars['Int']['output'];
    /** The Z coordinate of the voxel within the chunk. */
    voxelZ: Scalars['Int']['output'];
};
/** Input for sending a voxel update request to the UDP game server. This updates a single voxel (block) in a specific chunk. Voxel coordinates are relative to the chunk. */
export type VoxelUpdateRequestInput = {
    /** The ID of the app where the voxel is located. */
    appId: Scalars['BigInt']['input'];
    /** The chunk coordinates containing the voxel. A chunk is a 16x16x16 voxel cube. */
    chunk: ChunkCoordinatesInput;
    /** Decay algorithm for replication: 0 = none, 1 = exponential, 2 = linear 50%, 3 = linear 25%, 4 = linear 10%, 5 = linear 5%. Defaults to 0 (none) for voxel updates. */
    decayRate?: InputMaybe<Scalars['Int']['input']>;
    /** Chunk replication distance (0-8). Defaults to 8 for voxel updates. Clamped to 0-8. */
    distance?: InputMaybe<Scalars['Int']['input']>;
    /** Client-assigned correlation id for this datagram: a uint8 (0-255) that wraps at gameClientBootstrap.sequenceNumberModulo (256); defaults to 0 if omitted. For CORRELATION ONLY — it is NOT an idempotency key and the server does not dedupe replays. Echoed on the matching response and on any GenericErrorResponse for this send, both delivered on the udpNotifications subscription. */
    sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
    /** A unique identifier for this voxel update. Must be exactly 32 bytes when encoded as UTF-8. */
    uuid: Scalars['String']['input'];
    /** The voxel coordinates within the chunk. Values must be between -32768 and 32767 (int16 range). */
    voxel: VoxelCoordinatesInput;
    /** The voxel state data, base64-encoded. */
    voxelState: Scalars['String']['input'];
    /** The new voxel type ID. This determines the appearance and properties of the voxel. */
    voxelType: Scalars['Int']['input'];
};
/** LEGACY — never emitted. The game server retired the dedicated voxel-update response opcode (132); an applied update now arrives as your own VoxelUpdateNotification (the sender is included in the chunk fan-out) and failures arrive as GenericErrorResponse. This type remains in the UdpNotification union for backward compatibility only — do not select it in new code; it will be removed in a future major version. */
export type VoxelUpdateResponse = {
    __typename?: 'VoxelUpdateResponse';
    /** The ID of the app where the voxel update was processed. */
    appId: Scalars['BigInt']['output'];
    /** The X coordinate of the chunk containing the voxel. */
    chunkX: Scalars['BigInt']['output'];
    /** The Y coordinate of the chunk containing the voxel. */
    chunkY: Scalars['BigInt']['output'];
    /** The Z coordinate of the chunk containing the voxel. */
    chunkZ: Scalars['BigInt']['output'];
    /** Decay algorithm (0-5) from the original message. */
    decayRate: Scalars['Int']['output'];
    /** Chunk replication distance (0-8) from the original message. */
    distance: Scalars['Int']['output'];
    /** Server-generated epoch milliseconds timestamp. */
    epochMillis: Scalars['BigInt']['output'];
    /** The sequenceNumber echoed back from the originating sendVoxelUpdate request (a uint8, 0-255, wrapping at modulo 256). Use it to correlate this response with that send. Correlation only — not an idempotency key. */
    sequenceNumber: Scalars['Int']['output'];
    /** The unique identifier for this voxel update. */
    uuid: Scalars['String']['output'];
};
/** Result of listVoxelUpdatesByDistance: per-chunk groups of voxel edits ordered by increasing distance from the center, plus an echo of the pagination applied. */
export type VoxelUpdatesByDistanceResponse = {
    __typename?: 'VoxelUpdatesByDistanceResponse';
    /** The center chunk the search was performed around. */
    centerCoordinate: ChunkCoordinates;
    /** Per-chunk groups of voxel edits, ordered by increasing Chebyshev distance from centerCoordinate. */
    chunks: Array<ChunkVoxelUpdatesResponse>;
    /** Echo of the chunk `limit` applied to this page, or null if none was supplied. */
    limit: Maybe<Scalars['Int']['output']>;
    /** Echo of the chunk `skip` applied to this page, or null if none was supplied. */
    skip: Maybe<Scalars['Int']['output']>;
};
export type WalletTransaction = {
    __typename?: 'WalletTransaction';
    /** Signed change applied to the wallet in minor currency units (cents), as a BigInt decimal string: positive credits funds, negative debits funds. */
    amountCents: Scalars['BigInt']['output'];
    /** App that incurred the charge (BigInt as a decimal string), set on usage-type transactions; null for org-level credits such as top-ups. */
    appId: Maybe<Scalars['BigInt']['output']>;
    /** Wallet balance in cents immediately after this transaction was applied, as a BigInt decimal string. */
    balanceAfter: Scalars['BigInt']['output'];
    /** When the transaction was recorded (ISO-8601 UTC timestamp). */
    createdAt: Scalars['DateTime']['output'];
    /** Optional human-readable note describing the transaction; null when not set. */
    description: Maybe<Scalars['String']['output']>;
    /** Organization that owns the wallet (BigInt as a decimal string). */
    orgId: Scalars['BigInt']['output'];
    /** Optional external reference (e.g. payment-provider charge id or checkout id) linking this transaction to its source; null when not set. */
    referenceId: Maybe<Scalars['String']['output']>;
    /** Unique transaction id (BigInt as a decimal string). */
    transactionId: Scalars['BigInt']['output'];
    /** What produced this transaction. The complete set of values this API writes: "topup" (wallet credit from a completed checkout, positive), "admin_credit" (operator credit applied without a payment provider, positive), "auto_recharge" (off-session automatic wallet recharge, positive), "shared_usage" (hourly shared-environment metered charge for one closed clock hour, negative), "agent_usage" (Crowdy Studio agent run charged at provider cost, negative), "reserved_throughput" (monthly or prorated reserved egress capacity, negative), "markup_payout" (the app developer's markup on a player's compute bill, credited to the org in the same transaction as the player debit that produced it, positive). No other value is written; earlier versions of this description also listed "usage" and "environment_usage", neither of which was ever produced. */
    transactionType: Scalars['String']['output'];
    /** Wallet this transaction belongs to (BigInt as a decimal string). */
    walletId: Scalars['BigInt']['output'];
};
/** An edge in a WalletTransaction connection. */
export type WalletTransactionEdge = {
    __typename?: 'WalletTransactionEdge';
    /** Opaque cursor for this edge. */
    cursor: Scalars['String']['output'];
    /** The node at the end of this edge. */
    node: WalletTransaction;
};
/** A Relay cursor connection over WalletTransaction records. Page with first/after; pass pageInfo.endCursor back as after for the next page. */
export type WalletTransactionsConnection = {
    __typename?: 'WalletTransactionsConnection';
    /** Edges on this page. */
    edges: Array<WalletTransactionEdge>;
    /** Pagination metadata. */
    pageInfo: ConnectionPageInfo;
    /** Total matching records across all pages, when known (null for sources that do not compute a total). */
    totalCount: Maybe<Scalars['Int']['output']>;
};
/** A snapshot of an app's compute footprint: module/version/trigger counts plus recent run activity. Helps developers understand what compute is deployed and doing. */
export type WasmAppDiagnostics = {
    __typename?: 'WasmAppDiagnostics';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** Modules currently enabled. */
    enabledModuleCount: Scalars['Int']['output'];
    /** Failed runs in the last 24h. */
    failedRuns24h: Scalars['Int']['output'];
    /** Fuel consumed in the last 24h. */
    fuelUsed24h: Scalars['BigInt']['output'];
    /** Modules defined. */
    moduleCount: Scalars['Int']['output'];
    /** Runs in the last 24h. */
    runs24h: Scalars['Int']['output'];
    /** Rust compiler version of the toolchain on the replica that served this query (the boot-logged fingerprint; replicas with skewed toolchains produce disjoint compile-cache keys). Null when the toolchain is not provisioned on this host. */
    toolchainRustVersion: Maybe<Scalars['String']['output']>;
    /** wasm-opt version of the toolchain on the replica that served this query. Null when the toolchain is not provisioned on this host. */
    toolchainWasmOptVersion: Maybe<Scalars['String']['output']>;
    /** Most-active modules in the last 24h. */
    topModules: Array<WasmTopModule>;
    /** Trigger bindings defined. */
    triggerCount: Scalars['Int']['output'];
    /** Source versions uploaded (all modules). */
    versionCount: Scalars['Int']['output'];
};
/** Per-module rollup within a stats window. */
export type WasmComputeStat = {
    __typename?: 'WasmComputeStat';
    /** Average run duration (microseconds). */
    avgDurationUs: Scalars['Int']['output'];
    /** Current circuit-breaker state: closed | open | half_open. */
    circuitState: Scalars['String']['output'];
    /** Failed runs in the window. */
    failures: Scalars['Int']['output'];
    /** Total fuel consumed. */
    fuelUsed: Scalars['BigInt']['output'];
    /** The module name. */
    moduleName: Scalars['String']['output'];
    /** Runs in the window. */
    runs: Scalars['Int']['output'];
};
/** Aggregate compute activity for an app over a recent window: throughput, failure rate, fuel, egress, and a per-module breakdown. */
export type WasmComputeStats = {
    __typename?: 'WasmComputeStats';
    /** The instant through which these totals are complete. Activity is counted from per-minute usage rollups that each instance buffers in memory and writes every few seconds, so entry calls made after this instant are NOT included yet. Read it before concluding anything from a zero: `totalRuns: 0` with an `aggregatedThrough` a few seconds in the past means "nothing aggregated yet", not "nothing ran". Poll until `aggregatedThrough` is later than the run you are looking for. */
    aggregatedThrough: Scalars['DateTime']['output'];
    /** Average run duration in microseconds. */
    avgDurationUs: Scalars['Int']['output'];
    /** Per-module breakdown. */
    byModule: Array<WasmComputeStat>;
    /** Failed runs in the window. */
    failedRuns: Scalars['Int']['output'];
    /** Failure rate as a percentage (0-100). */
    failureRatePct: Scalars['Float']['output'];
    /** Total replication messages emitted in the window. */
    totalEgressMsgs: Scalars['BigInt']['output'];
    /** Total fuel consumed in the window. */
    totalFuelUsed: Scalars['BigInt']['output'];
    /** Total entry calls (ticks + invocations) in the window, complete through `aggregatedThrough`. */
    totalRuns: Scalars['Int']['output'];
    /** The window size in minutes. */
    windowMinutes: Scalars['Int']['output'];
};
/** A WASM compute module: developer-authored Rust compiled to sandboxed WASM on game-api instances. Holds metadata, the deployed version pointer, and circuit-breaker state; source lives in versions. */
export type WasmModule = {
    __typename?: 'WasmModule';
    /** Whether the module runs without active players (world simulation). Policy-gated. */
    alwaysOn: Scalars['Boolean']['output'];
    /** The app (tenant) that owns the module. */
    appId: Scalars['BigInt']['output'];
    /** When this module was stopped for exceeding a resource limit. Null when it is running normally. Unlike the circuit breaker this does not clear on its own: deploy a new version, or ask an admin to reset it. */
    breakerLatchedAt: Maybe<Scalars['DateTime']['output']>;
    /** What the module exceeded and what to change, when it has been stopped for a resource limit. Null when it is running normally. */
    breakerReason: Maybe<Scalars['String']['output']>;
    /** Circuit-breaker state: closed | open | half_open. */
    circuitState: Scalars['String']['output'];
    /** Current consecutive-failure count. */
    consecutiveFailures: Scalars['Int']['output'];
    /** When the open circuit may retry (half-open). */
    cooldownUntil: Maybe<Scalars['DateTime']['output']>;
    /** When the module was created. */
    createdAt: Scalars['DateTime']['output'];
    /** The deployed version id (UUID). Null until first deploy. */
    currentVersionId: Maybe<Scalars['String']['output']>;
    /** Optional description. */
    description: Maybe<Scalars['String']['output']>;
    /** Whether the module may run. New modules start disabled; enable after a successful compile. */
    enabled: Scalars['Boolean']['output'];
    /** The single most recent error string, overwritten by each new failure and CLEARED by the next success — so a module that fails intermittently reports null between failures. Do not read this as a health signal: use userCodeFaultSummary, which keeps every fault with its kind and blame. Kept for the "what went wrong just now" case it is genuinely good at. */
    lastError: Maybe<Scalars['String']['output']>;
    /** Unique module id (UUID). */
    moduleId: Scalars['String']['output'];
    /** Module name (unique per app); the upsert key. */
    name: Scalars['String']['output'];
    /** When the module was last updated. */
    updatedAt: Scalars['DateTime']['output'];
};
/** A diagnostic log line for a compute module. Phase 1 surfaces failed-run errors; the Phase 2 runtime adds guest ck.log output. */
export type WasmModuleLogEntry = {
    __typename?: 'WasmModuleLogEntry';
    /** Which ck-api instance produced the line. Null for runtime error lines, which are read back from the run table rather than attributed to an instance. Present on guest ck.log lines, which used to be served from the answering replica's memory and so silently excluded every other instance's output. */
    instanceId: Maybe<Scalars['String']['output']>;
    /** Log level: debug | info | warn | error. */
    level: Scalars['String']['output'];
    /** The log message. */
    message: Scalars['String']['output'];
    /** The module name. */
    moduleName: Scalars['String']['output'];
    /** The entry that produced the line: init | tick | event | invoke. */
    triggerSource: Maybe<Scalars['String']['output']>;
    /** When the line was recorded. */
    ts: Scalars['DateTime']['output'];
};
/** Per-app guardrails / platform ceilings for compute modules. A missing row means platform defaults. */
export type WasmModulePolicy = {
    __typename?: 'WasmModulePolicy';
    /** The app (tenant) the policy applies to. */
    appId: Scalars['BigInt']['output'];
    /** Cooldown (ms) while a module circuit is open. */
    cooldownMs: Scalars['Int']['output'];
    /** App-wide kill switch for all compute modules. */
    enabled: Scalars['Boolean']['output'];
    /** Consecutive failures that open a module circuit. */
    failureThreshold: Scalars['Int']['output'];
    /** Fuel budget per invoke/event call. */
    fuelPerInvoke: Scalars['BigInt']['output'];
    /** Fuel budget per tick call. */
    fuelPerTick: Scalars['BigInt']['output'];
    /** Max host data-API operations per tick. */
    maxDbOpsPerTick: Scalars['Int']['output'];
    /** Max replication bytes a module may emit per minute. */
    maxEgressBytesPerMin: Scalars['BigInt']['output'];
    /** Max replication messages a module may emit per minute. */
    maxEgressMsgsPerMin: Scalars['Int']['output'];
    /** Max guest linear memory (MB). */
    maxMemoryMb: Scalars['Int']['output'];
    /** Max modules the app may define. */
    maxModules: Scalars['Int']['output'];
    /** Wall-clock watchdog budget per entry call (ms). */
    maxRunMs: Scalars['Int']['output'];
    /** Max state bytes a module may write per minute. Saves beyond this are refused and ck.state_set returns false. */
    maxStateBytesPerMin: Scalars['BigInt']['output'];
    /** Max state saves a module may write per minute. Saves beyond this are refused and ck.state_set returns false. */
    maxStateWritesPerMin: Scalars['Int']['output'];
    /** Max tick rate (Hz) any module may request. */
    maxTickHz: Scalars['Float']['output'];
    /** Minimum gap in milliseconds between saves of a module’s state. Saves made inside the window are combined and the newest one is written, so a module that saves every tick still only writes once per window. */
    statePersistMinIntervalMs: Scalars['Int']['output'];
};
/** One recorded compute execution: timing, fuel, host-call counts, outcome. NOT a sample of all executions — a successful tick is deliberately not recorded here, because ticks are high-frequency and aggregate into per-minute usage instead, so this table holds every failure plus demand-driven runs plus the reload that follows a terminated worker. Counting rows here to get a success rate gives roughly 50% against a true 0.1-1.6%; computeModuleStats and computeAppDiagnostics read the per-minute rollups for that. Use this for what happened on an individual run and for flow correlation. */
export type WasmModuleRun = {
    __typename?: 'WasmModuleRun';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** Circuit action taken (e.g. opened, half_open_retry). */
    circuitAction: Maybe<Scalars['String']['output']>;
    /** Host data-API reads performed. */
    dbReads: Scalars['Int']['output'];
    /** Host data-API writes performed. */
    dbWrites: Scalars['Int']['output'];
    /** Wall-clock duration in microseconds. */
    durationUs: Scalars['Int']['output'];
    /** Replication bytes emitted. */
    egressBytes: Scalars['BigInt']['output'];
    /** Replication messages emitted. */
    egressMsgs: Scalars['Int']['output'];
    /** The guest entry point (e.g. an invoke export name). */
    entry: Maybe<Scalars['String']['output']>;
    /** Error message when the run failed (trap, fuel, watchdog). */
    errorMessage: Maybe<Scalars['String']['output']>;
    /** Flow correlation id: shared with gm event-log rows and automation runs caused by the same entry call (computeInvoke / automation run / player invoke); ticks mint their own. */
    flowId: Maybe<Scalars['String']['output']>;
    /** Fuel consumed by the run. */
    fuelUsed: Scalars['BigInt']['output'];
    /** The module that ran. */
    moduleId: Scalars['String']['output'];
    /** The module name at run time. */
    moduleName: Scalars['String']['output'];
    /** Unique run id (UUID). */
    runId: Scalars['String']['output'];
    /** When the run started. */
    startedAt: Scalars['DateTime']['output'];
    /** Whether the run succeeded. */
    success: Scalars['Boolean']['output'];
    /** What ran: init | tick | event | invoke. */
    triggerSource: Scalars['String']['output'];
};
/** A trigger binding on a compute module: a tick loop, a model/compute event subscription, or a client-invokable export. */
export type WasmModuleTrigger = {
    __typename?: 'WasmModuleTrigger';
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** Event filter: only this container type. */
    containerTypeName: Maybe<Scalars['String']['output']>;
    /** For invoke triggers: the typed contract (JSON: params/result field maps with int|float|string|bool|object|array types). The platform validates computeInvoke params against it pre-sandbox; client codegen reads it for typed wrappers. Null = undeclared. */
    contractJson: Maybe<Scalars['String']['output']>;
    /** When the trigger was created. */
    createdAt: Scalars['DateTime']['output'];
    /** Debounce/coalesce window in ms. */
    debounceMs: Scalars['Int']['output'];
    /** Event filter: only compute events with this name. */
    eventName: Maybe<Scalars['String']['output']>;
    /** For invoke triggers: the exported guest function name. */
    exportName: Maybe<Scalars['String']['output']>;
    /** Event filter: only this model function name. */
    functionName: Maybe<Scalars['String']['output']>;
    /** For invoke triggers: JSON authority tree gating who may invoke. Null = app admins only. */
    invokePolicyJson: Maybe<Scalars['String']['output']>;
    /** The module this trigger drives. */
    moduleId: Scalars['String']['output'];
    /** For event triggers: function_invoked | property_changed | container_created | compute_event. */
    onEvent: Maybe<Scalars['String']['output']>;
    /** Event filter: only this property key. */
    propertyKey: Maybe<Scalars['String']['output']>;
    /** For tick triggers: the tick rate in Hz. */
    tickHz: Maybe<Scalars['Float']['output']>;
    /** Unique trigger id (UUID). */
    triggerId: Scalars['String']['output'];
    /** Trigger type: tick | event | invoke. */
    triggerType: Scalars['String']['output'];
};
/** An immutable source version of a compute module, plus its compile pipeline status. Rows are created pending; a game-api instance compiles them (Phase 2 runtime). */
export type WasmModuleVersion = {
    __typename?: 'WasmModuleVersion';
    /** The guest ABI version the source targets. */
    abiVersion: Scalars['Int']['output'];
    /** The app (tenant). */
    appId: Scalars['BigInt']['output'];
    /** Compiler output (populated when compilation runs). */
    compileLog: Maybe<Scalars['String']['output']>;
    /** Compile status: pending | compiling | succeeded | failed. */
    compileStatus: Scalars['String']['output'];
    /** Size of the compiled artifact in bytes (after compile). */
    compiledSizeBytes: Maybe<Scalars['BigInt']['output']>;
    /** When this version was uploaded. */
    createdAt: Scalars['DateTime']['output'];
    /** The module this version belongs to. */
    moduleId: Scalars['String']['output'];
    /** When this version became the deployed version. */
    publishedAt: Maybe<Scalars['DateTime']['output']>;
    /** The crowdy-compute-sdk version the source targets. */
    sdkVersion: Scalars['String']['output'];
    /** JSON object mapping relative paths to file contents (the uploaded Rust source). */
    sourceFilesJson: Scalars['String']['output'];
    /** sha256 of the canonicalized source map; keys the compiled-artifact cache together with toolchain/SDK/ABI versions. */
    sourceHash: Scalars['String']['output'];
    /** Unique version id (UUID). */
    versionId: Scalars['String']['output'];
    /** Monotonic version number within the module. */
    versionNo: Scalars['Int']['output'];
};
/** A module and its recent run counts (diagnostics). */
export type WasmTopModule = {
    __typename?: 'WasmTopModule';
    /** Failed runs in the window. */
    failures: Scalars['Int']['output'];
    /** The module name. */
    moduleName: Scalars['String']['output'];
    /** Runs in the window. */
    runs: Scalars['Int']['output'];
};
export type ActorQueryVariables = Exact<{
    uuid: Scalars['String']['input'];
}>;
export type ActorQuery = {
    __typename?: 'Query';
    actor: {
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
        avatarId: string | null;
        privateState: string | null;
        publicState: string | null;
        createdAt: string;
        chunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    };
};
export type ActorsQueryVariables = Exact<{
    filter?: InputMaybe<ActorFilterInput>;
}>;
export type ActorsQuery = {
    __typename?: 'Query';
    actors: Array<{
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
        avatarId: string | null;
        privateState: string | null;
        publicState: string | null;
        createdAt: string;
        chunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    }>;
};
export type ActorsConnectionQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<ActorFilterInput>;
}>;
export type ActorsConnectionQuery = {
    __typename?: 'Query';
    actorsConnection: {
        __typename?: 'ActorsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'ActorEdge';
            cursor: string;
            node: {
                __typename?: 'Actor';
                uuid: string;
                appId: string;
                userId: string;
                avatarId: string | null;
                privateState: string | null;
                publicState: string | null;
                createdAt: string;
                chunk: {
                    __typename?: 'ChunkCoordinates';
                    x: string;
                    y: string;
                    z: string;
                };
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type BatchLookupActorsQueryVariables = Exact<{
    input: BatchActorLookupInput;
}>;
export type BatchLookupActorsQuery = {
    __typename?: 'Query';
    batchLookupActors: Array<{
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
        avatarId: string | null;
        privateState: string | null;
        publicState: string | null;
        createdAt: string;
        chunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    }>;
};
export type CreateActorMutationVariables = Exact<{
    input: CreateActorInput;
}>;
export type CreateActorMutation = {
    __typename?: 'Mutation';
    createActor: {
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
        avatarId: string | null;
        privateState: string | null;
        publicState: string | null;
        createdAt: string;
        chunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    };
};
export type DeleteActorMutationVariables = Exact<{
    uuid: Scalars['String']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type DeleteActorMutation = {
    __typename?: 'Mutation';
    deleteActor: {
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
    };
};
export type UpdateActorMutationVariables = Exact<{
    uuid: Scalars['String']['input'];
    input: UpdateActorInput;
}>;
export type UpdateActorMutation = {
    __typename?: 'Mutation';
    updateActor: {
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
        avatarId: string | null;
        privateState: string | null;
        publicState: string | null;
        createdAt: string;
        chunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    };
};
export type UpdateActorStateMutationVariables = Exact<{
    uuid: Scalars['String']['input'];
    input: UpdateActorStateInput;
}>;
export type UpdateActorStateMutation = {
    __typename?: 'Mutation';
    updateActorState: {
        __typename?: 'Actor';
        uuid: string;
        appId: string;
        userId: string;
        privateState: string | null;
        publicState: string | null;
    };
};
export type AppAccessTiersQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppAccessTiersQuery = {
    __typename?: 'Query';
    appAccessTiers: Array<{
        __typename?: 'AppAccessTier';
        tierId: string;
        appId: string;
        name: string;
        tierOrder: number;
        isFree: boolean;
        isDefault: boolean;
        priceCents: string | null;
        currency: string | null;
        billingPeriod: string | null;
        description: string | null;
        permissionKeys: Array<string>;
        status: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type AppGrantMemberCandidatesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppGrantMemberCandidatesQuery = {
    __typename?: 'Query';
    appGrantMemberCandidates: Array<{
        __typename?: 'AppGrantMemberCandidate';
        userId: string;
        email: string | null;
        gamertag: string | null;
    }>;
};
export type AppUserAccessByAppQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    status?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type AppUserAccessByAppQuery = {
    __typename?: 'Query';
    appUserAccessByApp: Array<{
        __typename?: 'AppUserAccess';
        appUserAccessId: string;
        appId: string;
        userId: string;
        tierId: string | null;
        status: string;
        grantedBy: string;
        subscriptionId: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type AppUserAccessConnectionQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
    status?: InputMaybe<Scalars['String']['input']>;
}>;
export type AppUserAccessConnectionQuery = {
    __typename?: 'Query';
    appUserAccessConnection: {
        __typename?: 'AppUserAccessConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'AppUserAccessEdge';
            cursor: string;
            node: {
                __typename?: 'AppUserAccess';
                appUserAccessId: string;
                appId: string;
                userId: string;
                tierId: string | null;
                status: string;
                grantedBy: string;
                subscriptionId: string | null;
                expiresAt: string | null;
                createdAt: string;
                updatedAt: string;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type ArchiveAccessTierMutationVariables = Exact<{
    tierId: Scalars['BigInt']['input'];
}>;
export type ArchiveAccessTierMutation = {
    __typename?: 'Mutation';
    archiveAccessTier: {
        __typename?: 'AppAccessTier';
        tierId: string;
        status: string;
        updatedAt: string;
    };
};
export type ClaimFreeAppAccessMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ClaimFreeAppAccessMutation = {
    __typename?: 'Mutation';
    claimFreeAppAccess: {
        __typename?: 'AppUserAccess';
        appUserAccessId: string;
        appId: string;
        userId: string;
        tierId: string | null;
        status: string;
        grantedBy: string;
        subscriptionId: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type CreateAccessTierMutationVariables = Exact<{
    input: CreateAccessTierInput;
}>;
export type CreateAccessTierMutation = {
    __typename?: 'Mutation';
    createAccessTier: {
        __typename?: 'AppAccessTier';
        tierId: string;
        appId: string;
        name: string;
        tierOrder: number;
        isFree: boolean;
        isDefault: boolean;
        priceCents: string | null;
        currency: string | null;
        billingPeriod: string | null;
        description: string | null;
        permissionKeys: Array<string>;
        status: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type GrantAppAccessMutationVariables = Exact<{
    input: GrantAppAccessInput;
}>;
export type GrantAppAccessMutation = {
    __typename?: 'Mutation';
    grantAppAccess: {
        __typename?: 'AppUserAccess';
        appUserAccessId: string;
        appId: string;
        userId: string;
        tierId: string | null;
        status: string;
        grantedBy: string;
        subscriptionId: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type GrantMyAppAccessMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GrantMyAppAccessMutation = {
    __typename?: 'Mutation';
    grantMyAppAccess: {
        __typename?: 'AppUserAccess';
        appUserAccessId: string;
        appId: string;
        userId: string;
        tierId: string | null;
        status: string;
        grantedBy: string;
        subscriptionId: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type MyAppAccessQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MyAppAccessQuery = {
    __typename?: 'Query';
    myAppAccess: {
        __typename?: 'AppUserAccess';
        appUserAccessId: string;
        appId: string;
        userId: string;
        tierId: string | null;
        status: string;
        grantedBy: string;
        subscriptionId: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type RevokeAppAccessMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type RevokeAppAccessMutation = {
    __typename?: 'Mutation';
    revokeAppAccess: {
        __typename?: 'AppUserAccess';
        appUserAccessId: string;
        appId: string;
        userId: string;
        tierId: string | null;
        status: string;
        grantedBy: string;
        subscriptionId: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type RuntimePermissionsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type RuntimePermissionsQuery = {
    __typename?: 'Query';
    runtimePermissions: Array<string>;
};
export type UpdateAccessTierMutationVariables = Exact<{
    tierId: Scalars['BigInt']['input'];
    input: UpdateAccessTierInput;
}>;
export type UpdateAccessTierMutation = {
    __typename?: 'Mutation';
    updateAccessTier: {
        __typename?: 'AppAccessTier';
        tierId: string;
        appId: string;
        name: string;
        tierOrder: number;
        isFree: boolean;
        isDefault: boolean;
        priceCents: string | null;
        currency: string | null;
        billingPeriod: string | null;
        description: string | null;
        permissionKeys: Array<string>;
        status: string;
        updatedAt: string;
    };
};
export type AppQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppQuery = {
    __typename?: 'Query';
    app: {
        __typename?: 'App';
        appId: string;
        orgId: string;
        name: string;
        slug: string | null;
        description: string | null;
        visibility: AppVisibility;
        status: AppStatus;
        metadata: string | null;
        splitMode: boolean;
        deploymentTarget: string;
        runtimeStatus: string;
        runtimeDenialReason: string | null;
        gameApiUrl: string | null;
        createdAt: string;
        updatedAt: string;
        org: {
            __typename?: 'Organization';
            orgId: string;
            slug: string;
            name: string;
        } | null;
    } | null;
};
export type AppBySlugQueryVariables = Exact<{
    orgSlug: Scalars['String']['input'];
    appSlug: Scalars['String']['input'];
}>;
export type AppBySlugQuery = {
    __typename?: 'Query';
    appBySlug: {
        __typename?: 'App';
        appId: string;
        orgId: string;
        name: string;
        slug: string | null;
        description: string | null;
        visibility: AppVisibility;
        status: AppStatus;
        metadata: string | null;
        splitMode: boolean;
        gameApiUrl: string | null;
        createdAt: string;
        updatedAt: string;
        org: {
            __typename?: 'Organization';
            orgId: string;
            slug: string;
            name: string;
        } | null;
    } | null;
};
export type AppDiscoveryQueryVariables = Exact<{
    appIds: Array<Scalars['BigInt']['input']> | Scalars['BigInt']['input'];
}>;
export type AppDiscoveryQuery = {
    __typename?: 'Query';
    appDiscovery: Array<{
        __typename?: 'AppDiscovery';
        appId: string;
        datacenterCode: string | null;
        gameApiUrl: string | null;
        gameApiWsUrl: string | null;
    }>;
};
export type AppsForOrgQueryVariables = Exact<{
    orgSlug: Scalars['String']['input'];
}>;
export type AppsForOrgQuery = {
    __typename?: 'Query';
    appsForOrg: Array<{
        __typename?: 'App';
        appId: string;
        orgId: string;
        name: string;
        slug: string | null;
        description: string | null;
        visibility: AppVisibility;
        status: AppStatus;
        metadata: string | null;
        splitMode: boolean;
        gameApiUrl: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type ArchiveAppMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ArchiveAppMutation = {
    __typename?: 'Mutation';
    archiveApp: {
        __typename?: 'App';
        appId: string;
        status: AppStatus;
        updatedAt: string;
    };
};
export type AppCodeAdmissionFieldsFragment = {
    __typename?: 'AppCodeAdmission';
    admissionId: string;
    appId: string;
    subjectKind: CodeAdmissionSubjectKind;
    subjectRef: string;
    versionRange: string | null;
    admittedBy: string;
    admittedAt: string;
    revokedAt: string | null;
};
export type AppCodeAdmissionModeQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppCodeAdmissionModeQuery = {
    __typename?: 'Query';
    appCodeAdmissionMode: CodeAdmissionMode;
};
export type AppCodeAdmissionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    includeRevoked?: InputMaybe<Scalars['Boolean']['input']>;
}>;
export type AppCodeAdmissionsQuery = {
    __typename?: 'Query';
    appCodeAdmissions: Array<{
        __typename?: 'AppCodeAdmission';
        admissionId: string;
        appId: string;
        subjectKind: CodeAdmissionSubjectKind;
        subjectRef: string;
        versionRange: string | null;
        admittedBy: string;
        admittedAt: string;
        revokedAt: string | null;
    }>;
};
export type SetAppCodeAdmissionModeMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    mode: CodeAdmissionMode;
}>;
export type SetAppCodeAdmissionModeMutation = {
    __typename?: 'Mutation';
    setAppCodeAdmissionMode: CodeAdmissionMode;
};
export type AdmitAppCodeMutationVariables = Exact<{
    input: AdmitAppCodeInput;
}>;
export type AdmitAppCodeMutation = {
    __typename?: 'Mutation';
    admitAppCode: {
        __typename?: 'AppCodeAdmission';
        admissionId: string;
        appId: string;
        subjectKind: CodeAdmissionSubjectKind;
        subjectRef: string;
        versionRange: string | null;
        admittedBy: string;
        admittedAt: string;
        revokedAt: string | null;
    };
};
export type RevokeAppCodeAdmissionMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    admissionId: Scalars['String']['input'];
}>;
export type RevokeAppCodeAdmissionMutation = {
    __typename?: 'Mutation';
    revokeAppCodeAdmission: {
        __typename?: 'AppCodeAdmission';
        admissionId: string;
        appId: string;
        subjectKind: CodeAdmissionSubjectKind;
        subjectRef: string;
        versionRange: string | null;
        admittedBy: string;
        admittedAt: string;
        revokedAt: string | null;
    };
};
export type CreateAppMutationVariables = Exact<{
    input: CreateAppInput;
}>;
export type CreateAppMutation = {
    __typename?: 'Mutation';
    createApp: {
        __typename?: 'App';
        appId: string;
        orgId: string;
        name: string;
        slug: string | null;
        description: string | null;
        visibility: AppVisibility;
        status: AppStatus;
        metadata: string | null;
        createdAt: string;
    };
};
export type MarketplaceAppsQueryVariables = Exact<{
    filter?: InputMaybe<AppMarketplaceFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type MarketplaceAppsQuery = {
    __typename?: 'Query';
    apps: {
        __typename?: 'AppsPage';
        items: Array<{
            __typename?: 'App';
            appId: string;
            orgId: string;
            name: string;
            slug: string | null;
            description: string | null;
            visibility: AppVisibility;
            status: AppStatus;
            metadata: string | null;
            splitMode: boolean;
            gameApiUrl: string | null;
            createdAt: string;
            updatedAt: string;
            org: {
                __typename?: 'Organization';
                orgId: string;
                slug: string;
                name: string;
            } | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            totalCount: number;
            limit: number;
            offset: number;
        };
    };
};
export type AppsConnectionQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<AppMarketplaceFilterInput>;
}>;
export type AppsConnectionQuery = {
    __typename?: 'Query';
    appsConnection: {
        __typename?: 'AppsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'AppEdge';
            cursor: string;
            node: {
                __typename?: 'App';
                appId: string;
                orgId: string;
                name: string;
                slug: string | null;
                description: string | null;
                visibility: AppVisibility;
                status: AppStatus;
                metadata: string | null;
                splitMode: boolean;
                gameApiUrl: string | null;
                createdAt: string;
                updatedAt: string;
                org: {
                    __typename?: 'Organization';
                    orgId: string;
                    slug: string;
                    name: string;
                } | null;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type MyAppsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type MyAppsQuery = {
    __typename?: 'Query';
    myApps: Array<{
        __typename?: 'App';
        appId: string;
        orgId: string;
        name: string;
        slug: string | null;
        description: string | null;
        visibility: AppVisibility;
        status: AppStatus;
        metadata: string | null;
        splitMode: boolean;
        gameApiUrl: string | null;
        createdAt: string;
        updatedAt: string;
        org: {
            __typename?: 'Organization';
            orgId: string;
            slug: string;
            name: string;
        } | null;
    }>;
};
export type PlaceableDatacentersQueryVariables = Exact<{
    [key: string]: never;
}>;
export type PlaceableDatacentersQuery = {
    __typename?: 'Query';
    placeableDatacenters: {
        __typename?: 'PlaceableDatacenters';
        placementEnforced: boolean;
        servedBy: string | null;
        datacenters: Array<{
            __typename?: 'PlaceableDatacenter';
            code: string;
            placeable: boolean;
            serving: DatacenterServingStatus;
            appShardCount: number;
            gameApiUrl: string | null;
            gameApiWsUrl: string | null;
        }>;
    };
};
export type SetAppVisibilityMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    visibility: AppVisibility;
}>;
export type SetAppVisibilityMutation = {
    __typename?: 'Mutation';
    setAppVisibility: {
        __typename?: 'App';
        appId: string;
        visibility: AppVisibility;
        updatedAt: string;
    };
};
export type UpdateAppMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    input: UpdateAppInput;
}>;
export type UpdateAppMutation = {
    __typename?: 'Mutation';
    updateApp: {
        __typename?: 'App';
        appId: string;
        orgId: string;
        name: string;
        slug: string | null;
        description: string | null;
        visibility: AppVisibility;
        status: AppStatus;
        metadata: string | null;
        updatedAt: string;
    };
};
export type LogoutMutationVariables = Exact<{
    [key: string]: never;
}>;
export type LogoutMutation = {
    __typename?: 'Mutation';
    logout: boolean;
};
export type LogoutAllDevicesMutationVariables = Exact<{
    [key: string]: never;
}>;
export type LogoutAllDevicesMutation = {
    __typename?: 'Mutation';
    logoutAllDevices: boolean;
};
export type UserAvatarsQueryVariables = Exact<{
    userId: Scalars['BigInt']['input'];
}>;
export type UserAvatarsQuery = {
    __typename?: 'Query';
    userAvatars: Array<{
        __typename?: 'Avatar';
        avatarId: string;
        userId: string;
        name: string;
        publicState: string | null;
        privateState: string | null;
        createdAt: string;
    }>;
};
export type AvatarByIdQueryVariables = Exact<{
    id: Scalars['BigInt']['input'];
}>;
export type AvatarByIdQuery = {
    __typename?: 'Query';
    avatar: {
        __typename?: 'Avatar';
        avatarId: string;
        userId: string;
        name: string;
        publicState: string | null;
        privateState: string | null;
        createdAt: string;
    };
};
export type MyAvatarsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type MyAvatarsQuery = {
    __typename?: 'Query';
    myAvatars: Array<{
        __typename?: 'AvatarDTO';
        avatarId: string;
        userId: string;
        name: string;
        publicState: string | null;
        privateState: string | null;
        createdAt: string;
    }>;
};
export type AvatarAppStateQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    avatarId: Scalars['BigInt']['input'];
}>;
export type AvatarAppStateQuery = {
    __typename?: 'Query';
    avatarAppState: {
        __typename?: 'AppAvatarState';
        appId: string;
        avatarId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type AvatarAppStatesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    avatarIds: Array<Scalars['BigInt']['input']> | Scalars['BigInt']['input'];
}>;
export type AvatarAppStatesQuery = {
    __typename?: 'Query';
    avatarAppStates: Array<{
        __typename?: 'AppAvatarState';
        appId: string;
        avatarId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type CreateAvatarMutationVariables = Exact<{
    input: CreateAvatarInput;
}>;
export type CreateAvatarMutation = {
    __typename?: 'Mutation';
    createAvatar: {
        __typename?: 'Avatar';
        avatarId: string;
        userId: string;
        name: string;
        publicState: string | null;
        privateState: string | null;
        createdAt: string;
    };
};
export type UpdateAvatarMutationVariables = Exact<{
    id: Scalars['BigInt']['input'];
    input: UpdateAvatarInput;
}>;
export type UpdateAvatarMutation = {
    __typename?: 'Mutation';
    updateAvatar: {
        __typename?: 'Avatar';
        avatarId: string;
        userId: string;
        name: string;
        publicState: string | null;
        privateState: string | null;
        createdAt: string;
    };
};
export type DeleteAvatarMutationVariables = Exact<{
    id: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type DeleteAvatarMutation = {
    __typename?: 'Mutation';
    deleteAvatar: {
        __typename?: 'Avatar';
        avatarId: string;
        userId: string;
        name: string;
        createdAt: string;
    };
};
export type UpdateAvatarStateMutationVariables = Exact<{
    id: Scalars['BigInt']['input'];
    input: UpdateAvatarStateInput;
}>;
export type UpdateAvatarStateMutation = {
    __typename?: 'Mutation';
    updateAvatarState: {
        __typename?: 'Avatar';
        avatarId: string;
        userId: string;
        name: string;
        publicState: string | null;
        privateState: string | null;
        createdAt: string;
    };
};
export type UpdateAvatarAppStateMutationVariables = Exact<{
    input: UpdateAvatarAppStateInput;
}>;
export type UpdateAvatarAppStateMutation = {
    __typename?: 'Mutation';
    updateAvatarAppState: {
        __typename?: 'AppAvatarState';
        appId: string;
        avatarId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type AppBudgetQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    appId: Scalars['BigInt']['input'];
}>;
export type AppBudgetQuery = {
    __typename?: 'Query';
    appBudget: {
        __typename?: 'AppBudget';
        appBudgetId: string;
        orgId: string;
        appId: string;
        monthlyLimitCents: string | null;
        currentMonthUsageCents: string;
        periodStart: string;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type AppBudgetsQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type AppBudgetsQuery = {
    __typename?: 'Query';
    appBudgets: Array<{
        __typename?: 'AppBudget';
        appBudgetId: string;
        orgId: string;
        appId: string;
        monthlyLimitCents: string | null;
        currentMonthUsageCents: string;
        periodStart: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type SetAppBudgetMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    appId: Scalars['BigInt']['input'];
    monthlyLimitCents: Scalars['BigInt']['input'];
}>;
export type SetAppBudgetMutation = {
    __typename?: 'Mutation';
    setAppBudget: {
        __typename?: 'AppBudget';
        appBudgetId: string;
        orgId: string;
        appId: string;
        monthlyLimitCents: string | null;
        currentMonthUsageCents: string;
        periodStart: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type WalletBalanceQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type WalletBalanceQuery = {
    __typename?: 'Query';
    walletBalance: {
        __typename?: 'OrgWallet';
        walletId: string;
        orgId: string;
        balanceCents: string;
        currency: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type WalletTransactionsQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type WalletTransactionsQuery = {
    __typename?: 'Query';
    walletTransactions: Array<{
        __typename?: 'WalletTransaction';
        transactionId: string;
        walletId: string;
        orgId: string;
        amountCents: string;
        balanceAfter: string;
        transactionType: string;
        description: string | null;
        referenceId: string | null;
        appId: string | null;
        createdAt: string;
    }>;
};
export type WalletTransactionsConnectionQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
}>;
export type WalletTransactionsConnectionQuery = {
    __typename?: 'Query';
    walletTransactionsConnection: {
        __typename?: 'WalletTransactionsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'WalletTransactionEdge';
            cursor: string;
            node: {
                __typename?: 'WalletTransaction';
                transactionId: string;
                walletId: string;
                orgId: string;
                amountCents: string;
                balanceAfter: string;
                transactionType: string;
                description: string | null;
                referenceId: string | null;
                appId: string | null;
                createdAt: string;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type AddChannelMemberMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type AddChannelMemberMutation = {
    __typename?: 'Mutation';
    addChannelMember: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type ChannelQueryVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type ChannelQuery = {
    __typename?: 'Query';
    channel: {
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    };
};
export type ChannelMembersQueryVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type ChannelMembersQuery = {
    __typename?: 'Query';
    channelMembers: Array<{
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    }>;
};
export type ChannelPolicyQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ChannelPolicyQuery = {
    __typename?: 'Query';
    channelPolicy: {
        __typename?: 'AppGroupPolicy';
        appId: string;
        groupType: string;
        creationPolicy: string;
        defaultMembershipPolicy: string;
        maxMembers: number | null;
        maxGroupsPerUser: number | null;
    };
};
export type ChannelRolesQueryVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type ChannelRolesQuery = {
    __typename?: 'Query';
    channelRoles: Array<{
        __typename?: 'GroupRole';
        groupRoleId: string;
        groupId: string;
        roleName: string;
        rank: number;
        isSystem: boolean;
        permissions: Array<string>;
        createdAt: string;
    }>;
};
export type ChannelsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ChannelsQuery = {
    __typename?: 'Query';
    channels: Array<{
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    }>;
};
export type CreateChannelMutationVariables = Exact<{
    input: CreateChannelInput;
}>;
export type CreateChannelMutation = {
    __typename?: 'Mutation';
    createChannel: {
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    };
};
export type CreateChannelRoleMutationVariables = Exact<{
    input: CreateGroupRoleInput;
}>;
export type CreateChannelRoleMutation = {
    __typename?: 'Mutation';
    createChannelRole: {
        __typename?: 'GroupRole';
        groupRoleId: string;
        groupId: string;
        roleName: string;
        rank: number;
        isSystem: boolean;
        permissions: Array<string>;
        createdAt: string;
    };
};
export type DeleteChannelMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type DeleteChannelMutation = {
    __typename?: 'Mutation';
    deleteChannel: boolean;
};
export type DeleteChannelRoleMutationVariables = Exact<{
    groupRoleId: Scalars['BigInt']['input'];
}>;
export type DeleteChannelRoleMutation = {
    __typename?: 'Mutation';
    deleteChannelRole: boolean;
};
export type JoinChannelMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type JoinChannelMutation = {
    __typename?: 'Mutation';
    joinChannel: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type LeaveChannelMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type LeaveChannelMutation = {
    __typename?: 'Mutation';
    leaveChannel: boolean;
};
export type MyChannelsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MyChannelsQuery = {
    __typename?: 'Query';
    myChannels: Array<{
        __typename?: 'GroupMembership';
        permissions: Array<string>;
        joinedAt: string;
        group: {
            __typename?: 'Group';
            groupId: string;
            appId: string;
            groupType: string;
            name: string;
            description: string | null;
            ownerUserId: string | null;
            membershipPolicy: string;
            status: string;
            defaultRoleId: string | null;
            createdAt: string;
        };
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    }>;
};
export type RemoveChannelMemberMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type RemoveChannelMemberMutation = {
    __typename?: 'Mutation';
    removeChannelMember: boolean;
};
export type RequestToJoinChannelMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type RequestToJoinChannelMutation = {
    __typename?: 'Mutation';
    requestToJoinChannel: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type SetChannelMemberRolesMutationVariables = Exact<{
    input: SetMemberRolesInput;
}>;
export type SetChannelMemberRolesMutation = {
    __typename?: 'Mutation';
    setChannelMemberRoles: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type SetChannelPolicyMutationVariables = Exact<{
    input: SetChannelPolicyInput;
}>;
export type SetChannelPolicyMutation = {
    __typename?: 'Mutation';
    setChannelPolicy: {
        __typename?: 'AppGroupPolicy';
        appId: string;
        groupType: string;
        creationPolicy: string;
        defaultMembershipPolicy: string;
        maxMembers: number | null;
        maxGroupsPerUser: number | null;
    };
};
export type UpdateChannelMutationVariables = Exact<{
    input: UpdateChannelInput;
}>;
export type UpdateChannelMutation = {
    __typename?: 'Mutation';
    updateChannel: {
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    };
};
export type UpdateChannelRoleMutationVariables = Exact<{
    input: UpdateGroupRoleInput;
}>;
export type UpdateChannelRoleMutation = {
    __typename?: 'Mutation';
    updateChannelRole: {
        __typename?: 'GroupRole';
        groupRoleId: string;
        groupId: string;
        roleName: string;
        rank: number;
        isSystem: boolean;
        permissions: Array<string>;
        createdAt: string;
    };
};
export type GetChunkQueryVariables = Exact<{
    input: GetChunkInput;
}>;
export type GetChunkQuery = {
    __typename?: 'Query';
    getChunk: {
        __typename?: 'Chunk';
        chunkId: string;
        appId: string;
        voxels: string | null;
        owner: string | null;
        createdAt: string;
        updatedAt: string;
        chunkState: string | null;
        cdnUploadedAt: string | null;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        voxelStates: Array<{
            __typename?: 'VoxelState';
            voxelType: number;
            state: string | null;
            voxelCoord: {
                __typename?: 'VoxelCoordinates';
                x: number;
                y: number;
                z: number;
            };
        }>;
        lods: Array<{
            __typename?: 'LodData';
            level: number;
            data: string;
        }> | null;
    } | null;
};
export type GetChunkLodsQueryVariables = Exact<{
    input: GetChunkLodsInput;
}>;
export type GetChunkLodsQuery = {
    __typename?: 'Query';
    getChunkLods: {
        __typename?: 'ChunkLodsResponse';
        chunkId: string;
        appId: string;
        updatedAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        lods: Array<{
            __typename?: 'LodData';
            level: number;
            data: string;
        }>;
    } | null;
};
export type GetChunksByDistanceQueryVariables = Exact<{
    input: GetChunksByDistanceInput;
}>;
export type GetChunksByDistanceQuery = {
    __typename?: 'Query';
    getChunksByDistance: {
        __typename?: 'ChunksByDistanceResponse';
        limit: number | null;
        skip: number | null;
        chunks: Array<{
            __typename?: 'Chunk';
            chunkId: string;
            appId: string;
            voxels: string | null;
            owner: string | null;
            createdAt: string;
            updatedAt: string;
            chunkState: string | null;
            cdnUploadedAt: string | null;
            coordinates: {
                __typename?: 'ChunkCoordinates';
                x: string;
                y: string;
                z: string;
            };
            lods: Array<{
                __typename?: 'LodData';
                level: number;
                data: string;
            }> | null;
        }>;
    };
};
export type GetVoxelListQueryVariables = Exact<{
    input: GetVoxelListInput;
}>;
export type GetVoxelListQuery = {
    __typename?: 'Query';
    getVoxelList: {
        __typename?: 'ChunkVoxelResponse';
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        voxels: Array<{
            __typename?: 'Voxel';
            voxelUpdateId: string;
            appId: string;
            voxelType: number;
            state: string | null;
            createdBy: string;
            createdAt: string;
            coordinates: {
                __typename?: 'ChunkCoordinates';
                x: string;
                y: string;
                z: string;
            };
            location: {
                __typename?: 'VoxelCoordinates';
                x: number;
                y: number;
                z: number;
            };
        }>;
    };
};
export type UpdateChunkMutationVariables = Exact<{
    input: ChunkUpdateInput;
}>;
export type UpdateChunkMutation = {
    __typename?: 'Mutation';
    updateChunk: {
        __typename?: 'Chunk';
        chunkId: string;
        appId: string;
        voxels: string | null;
        chunkState: string | null;
        updatedAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    };
};
export type UpdateChunkLodsMutationVariables = Exact<{
    input: UpdateChunkLodsInput;
}>;
export type UpdateChunkLodsMutation = {
    __typename?: 'Mutation';
    updateChunkLods: {
        __typename?: 'Chunk';
        chunkId: string;
        appId: string;
        updatedAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        lods: Array<{
            __typename?: 'LodData';
            level: number;
            data: string;
        }> | null;
    } | null;
};
export type UpdateChunkStateMutationVariables = Exact<{
    input: UpdateChunkStateInput;
}>;
export type UpdateChunkStateMutation = {
    __typename?: 'Mutation';
    updateChunkState: {
        __typename?: 'Chunk';
        chunkId: string;
        appId: string;
        chunkState: string | null;
        updatedAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    } | null;
};
export type ComputeModuleFieldsFragment = {
    __typename?: 'WasmModule';
    moduleId: string;
    appId: string;
    name: string;
    description: string | null;
    enabled: boolean;
    alwaysOn: boolean;
    currentVersionId: string | null;
    circuitState: string;
    consecutiveFailures: number;
    cooldownUntil: string | null;
    breakerLatchedAt: string | null;
    breakerReason: string | null;
    lastError: string | null;
    createdAt: string;
    updatedAt: string;
};
export type ComputeVersionFieldsFragment = {
    __typename?: 'WasmModuleVersion';
    versionId: string;
    moduleId: string;
    appId: string;
    versionNo: number;
    sourceHash: string;
    sdkVersion: string;
    abiVersion: number;
    compileStatus: string;
    compileLog: string | null;
    compiledSizeBytes: string | null;
    publishedAt: string | null;
    createdAt: string;
};
export type ComputeTriggerFieldsFragment = {
    __typename?: 'WasmModuleTrigger';
    triggerId: string;
    appId: string;
    moduleId: string;
    triggerType: string;
    tickHz: number | null;
    onEvent: string | null;
    functionName: string | null;
    containerTypeName: string | null;
    propertyKey: string | null;
    eventName: string | null;
    debounceMs: number;
    exportName: string | null;
    invokePolicyJson: string | null;
    contractJson: string | null;
    createdAt: string;
};
export type ComputePolicyFieldsFragment = {
    __typename?: 'WasmModulePolicy';
    appId: string;
    enabled: boolean;
    maxModules: number;
    maxTickHz: number;
    fuelPerTick: string;
    fuelPerInvoke: string;
    maxMemoryMb: number;
    maxRunMs: number;
    maxDbOpsPerTick: number;
    maxEgressMsgsPerMin: number;
    maxEgressBytesPerMin: string;
    failureThreshold: number;
    cooldownMs: number;
    statePersistMinIntervalMs: number;
    maxStateWritesPerMin: number;
    maxStateBytesPerMin: string;
};
export type ComputeRunFieldsFragment = {
    __typename?: 'WasmModuleRun';
    runId: string;
    appId: string;
    flowId: string | null;
    moduleId: string;
    moduleName: string;
    triggerSource: string;
    entry: string | null;
    startedAt: string;
    durationUs: number;
    fuelUsed: string;
    dbReads: number;
    dbWrites: number;
    egressMsgs: number;
    egressBytes: string;
    success: boolean;
    errorMessage: string | null;
    circuitAction: string | null;
};
export type ComputeUpsertModuleMutationVariables = Exact<{
    input: UpsertComputeModuleInput;
}>;
export type ComputeUpsertModuleMutation = {
    __typename?: 'Mutation';
    computeUpsertModule: {
        __typename?: 'WasmModule';
        moduleId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        alwaysOn: boolean;
        currentVersionId: string | null;
        circuitState: string;
        consecutiveFailures: number;
        cooldownUntil: string | null;
        breakerLatchedAt: string | null;
        breakerReason: string | null;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type ComputeDeployVersionMutationVariables = Exact<{
    input: DeployComputeVersionInput;
}>;
export type ComputeDeployVersionMutation = {
    __typename?: 'Mutation';
    computeDeployVersion: {
        __typename?: 'WasmModuleVersion';
        versionId: string;
        moduleId: string;
        appId: string;
        versionNo: number;
        sourceHash: string;
        sdkVersion: string;
        abiVersion: number;
        compileStatus: string;
        compileLog: string | null;
        compiledSizeBytes: string | null;
        publishedAt: string | null;
        createdAt: string;
    };
};
export type ComputeSetModuleEnabledMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    enabled: Scalars['Boolean']['input'];
}>;
export type ComputeSetModuleEnabledMutation = {
    __typename?: 'Mutation';
    computeSetModuleEnabled: {
        __typename?: 'WasmModule';
        moduleId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        alwaysOn: boolean;
        currentVersionId: string | null;
        circuitState: string;
        consecutiveFailures: number;
        cooldownUntil: string | null;
        breakerLatchedAt: string | null;
        breakerReason: string | null;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type ComputeResetBreakerMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    reason: Scalars['String']['input'];
}>;
export type ComputeResetBreakerMutation = {
    __typename?: 'Mutation';
    computeResetBreaker: {
        __typename?: 'WasmModule';
        moduleId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        alwaysOn: boolean;
        currentVersionId: string | null;
        circuitState: string;
        consecutiveFailures: number;
        cooldownUntil: string | null;
        breakerLatchedAt: string | null;
        breakerReason: string | null;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type ComputeDeleteModuleMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type ComputeDeleteModuleMutation = {
    __typename?: 'Mutation';
    computeDeleteModule: boolean;
};
export type ComputeUpsertTriggerMutationVariables = Exact<{
    input: UpsertComputeTriggerInput;
}>;
export type ComputeUpsertTriggerMutation = {
    __typename?: 'Mutation';
    computeUpsertTrigger: {
        __typename?: 'WasmModuleTrigger';
        triggerId: string;
        appId: string;
        moduleId: string;
        triggerType: string;
        tickHz: number | null;
        onEvent: string | null;
        functionName: string | null;
        containerTypeName: string | null;
        propertyKey: string | null;
        eventName: string | null;
        debounceMs: number;
        exportName: string | null;
        invokePolicyJson: string | null;
        contractJson: string | null;
        createdAt: string;
    };
};
export type ComputeDeleteTriggerMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    triggerId: Scalars['String']['input'];
}>;
export type ComputeDeleteTriggerMutation = {
    __typename?: 'Mutation';
    computeDeleteTrigger: boolean;
};
export type ComputeSetPolicyMutationVariables = Exact<{
    input: SetComputePolicyInput;
}>;
export type ComputeSetPolicyMutation = {
    __typename?: 'Mutation';
    computeSetPolicy: {
        __typename?: 'WasmModulePolicy';
        appId: string;
        enabled: boolean;
        maxModules: number;
        maxTickHz: number;
        fuelPerTick: string;
        fuelPerInvoke: string;
        maxMemoryMb: number;
        maxRunMs: number;
        maxDbOpsPerTick: number;
        maxEgressMsgsPerMin: number;
        maxEgressBytesPerMin: string;
        failureThreshold: number;
        cooldownMs: number;
        statePersistMinIntervalMs: number;
        maxStateWritesPerMin: number;
        maxStateBytesPerMin: string;
    };
};
export type ComputeInvokeMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    moduleName: Scalars['String']['input'];
    exportName: Scalars['String']['input'];
    paramsJson?: InputMaybe<Scalars['String']['input']>;
}>;
export type ComputeInvokeMutation = {
    __typename?: 'Mutation';
    computeInvoke: {
        __typename?: 'ComputeInvokeResult';
        resultBase64: string;
        resultJson: string | null;
        fuelUsed: string;
        durationUs: number;
    };
};
export type ComputeModulesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ComputeModulesQuery = {
    __typename?: 'Query';
    computeModules: Array<{
        __typename?: 'WasmModule';
        moduleId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        alwaysOn: boolean;
        currentVersionId: string | null;
        circuitState: string;
        consecutiveFailures: number;
        cooldownUntil: string | null;
        breakerLatchedAt: string | null;
        breakerReason: string | null;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type ComputeModuleQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type ComputeModuleQuery = {
    __typename?: 'Query';
    computeModule: {
        __typename?: 'WasmModule';
        moduleId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        alwaysOn: boolean;
        currentVersionId: string | null;
        circuitState: string;
        consecutiveFailures: number;
        cooldownUntil: string | null;
        breakerLatchedAt: string | null;
        breakerReason: string | null;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type ComputeModuleVersionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    moduleName: Scalars['String']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type ComputeModuleVersionsQuery = {
    __typename?: 'Query';
    computeModuleVersions: Array<{
        __typename?: 'WasmModuleVersion';
        versionId: string;
        moduleId: string;
        appId: string;
        versionNo: number;
        sourceHash: string;
        sdkVersion: string;
        abiVersion: number;
        compileStatus: string;
        compileLog: string | null;
        compiledSizeBytes: string | null;
        publishedAt: string | null;
        createdAt: string;
    }>;
};
export type ComputeModuleTriggersQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
}>;
export type ComputeModuleTriggersQuery = {
    __typename?: 'Query';
    computeModuleTriggers: Array<{
        __typename?: 'WasmModuleTrigger';
        triggerId: string;
        appId: string;
        moduleId: string;
        triggerType: string;
        tickHz: number | null;
        onEvent: string | null;
        functionName: string | null;
        containerTypeName: string | null;
        propertyKey: string | null;
        eventName: string | null;
        debounceMs: number;
        exportName: string | null;
        invokePolicyJson: string | null;
        contractJson: string | null;
        createdAt: string;
    }>;
};
export type ComputeModulePolicyQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ComputeModulePolicyQuery = {
    __typename?: 'Query';
    computeModulePolicy: {
        __typename?: 'WasmModulePolicy';
        appId: string;
        enabled: boolean;
        maxModules: number;
        maxTickHz: number;
        fuelPerTick: string;
        fuelPerInvoke: string;
        maxMemoryMb: number;
        maxRunMs: number;
        maxDbOpsPerTick: number;
        maxEgressMsgsPerMin: number;
        maxEgressBytesPerMin: string;
        failureThreshold: number;
        cooldownMs: number;
        statePersistMinIntervalMs: number;
        maxStateWritesPerMin: number;
        maxStateBytesPerMin: string;
    };
};
export type ComputeModuleRunsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type ComputeModuleRunsQuery = {
    __typename?: 'Query';
    computeModuleRuns: Array<{
        __typename?: 'WasmModuleRun';
        runId: string;
        appId: string;
        flowId: string | null;
        moduleId: string;
        moduleName: string;
        triggerSource: string;
        entry: string | null;
        startedAt: string;
        durationUs: number;
        fuelUsed: string;
        dbReads: number;
        dbWrites: number;
        egressMsgs: number;
        egressBytes: string;
        success: boolean;
        errorMessage: string | null;
        circuitAction: string | null;
    }>;
};
export type ComputeModuleStatsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
}>;
export type ComputeModuleStatsQuery = {
    __typename?: 'Query';
    computeModuleStats: {
        __typename?: 'WasmComputeStats';
        windowMinutes: number;
        totalRuns: number;
        failedRuns: number;
        failureRatePct: number;
        totalFuelUsed: string;
        totalEgressMsgs: string;
        avgDurationUs: number;
        byModule: Array<{
            __typename?: 'WasmComputeStat';
            moduleName: string;
            runs: number;
            failures: number;
            fuelUsed: string;
            avgDurationUs: number;
            circuitState: string;
        }>;
    };
};
export type ComputeModuleLogsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type ComputeModuleLogsQuery = {
    __typename?: 'Query';
    computeModuleLogs: Array<{
        __typename?: 'WasmModuleLogEntry';
        ts: string;
        moduleName: string;
        level: string;
        message: string;
        triggerSource: string | null;
    }>;
};
export type ComputeAppDiagnosticsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ComputeAppDiagnosticsQuery = {
    __typename?: 'Query';
    computeAppDiagnostics: {
        __typename?: 'WasmAppDiagnostics';
        appId: string;
        moduleCount: number;
        enabledModuleCount: number;
        versionCount: number;
        triggerCount: number;
        runs24h: number;
        failedRuns24h: number;
        fuelUsed24h: string;
        toolchainRustVersion: string | null;
        toolchainWasmOptVersion: string | null;
        topModules: Array<{
            __typename?: 'WasmTopModule';
            moduleName: string;
            runs: number;
            failures: number;
        }>;
    };
};
export type ComputeTemplatesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type ComputeTemplatesQuery = {
    __typename?: 'Query';
    computeTemplates: Array<{
        __typename?: 'ComputeTemplateInfo';
        name: string;
        description: string;
        exports: Array<string>;
    }>;
};
export type ComputeDeployTemplateMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    templateName: Scalars['String']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
}>;
export type ComputeDeployTemplateMutation = {
    __typename?: 'Mutation';
    computeDeployTemplate: {
        __typename?: 'WasmModule';
        moduleId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        alwaysOn: boolean;
        currentVersionId: string | null;
        circuitState: string;
        consecutiveFailures: number;
        cooldownUntil: string | null;
        breakerLatchedAt: string | null;
        breakerReason: string | null;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type CpComputePlatformCeilingsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type CpComputePlatformCeilingsQuery = {
    __typename?: 'Query';
    cpComputePlatformCeilings: {
        __typename?: 'CpComputePlatformCeilings';
        maxModules: number | null;
        maxTickHz: number | null;
        fuelPerTick: string | null;
        fuelPerInvoke: string | null;
        maxMemoryMb: number | null;
        maxRunMs: number | null;
        maxDbOpsPerTick: number | null;
        maxEgressMsgsPerMin: number | null;
        maxEgressBytesPerMin: string | null;
        updatedAt: string;
        updatedByUserId: string | null;
    };
};
export type CpSetComputePlatformCeilingsMutationVariables = Exact<{
    input: CpSetComputePlatformCeilingsInput;
}>;
export type CpSetComputePlatformCeilingsMutation = {
    __typename?: 'Mutation';
    cpSetComputePlatformCeilings: {
        __typename?: 'CpComputePlatformCeilings';
        maxModules: number | null;
        maxTickHz: number | null;
        fuelPerTick: string | null;
        fuelPerInvoke: string | null;
        maxMemoryMb: number | null;
        maxRunMs: number | null;
        maxDbOpsPerTick: number | null;
        maxEgressMsgsPerMin: number | null;
        maxEgressBytesPerMin: string | null;
        updatedAt: string;
        updatedByUserId: string | null;
    };
};
export type CrowdyStudioProjectFieldsFragment = {
    __typename?: 'CrowdyStudioProject';
    projectId: string;
    appId: string;
    ownerUserId: string;
    gridId: string | null;
    name: string;
    description: string | null;
    serverModuleName: string | null;
    clientModuleName: string | null;
    pairingPreference: CrowdyStudioPairingPreference;
    sdkVersion: string;
    abiVersion: number;
    revision: string;
    archived: boolean;
    archivedAt: string | null;
    fileCount: number;
    totalBytes: string;
    createdAt: string;
    updatedAt: string;
    files: Array<{
        __typename?: 'CrowdyStudioProjectFile';
        target: CrowdyStudioTarget;
        path: string;
        content: string;
        revision: string;
        provenance: CrowdyStudioFileProvenance;
        provenanceLibraryFileId: string | null;
        provenanceLibraryRevision: string | null;
        provenanceCommonVersionId: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type CrowdyStudioProjectsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    includeArchived?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type CrowdyStudioProjectsQuery = {
    __typename?: 'Query';
    crowdyStudioProjects: Array<{
        __typename?: 'CrowdyStudioProject';
        projectId: string;
        gridId: string | null;
        name: string;
        serverModuleName: string | null;
        clientModuleName: string | null;
        pairingPreference: CrowdyStudioPairingPreference;
        revision: string;
        archived: boolean;
        updatedAt: string;
    }>;
};
export type CrowdyStudioProjectQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    projectId: Scalars['String']['input'];
}>;
export type CrowdyStudioProjectQuery = {
    __typename?: 'Query';
    crowdyStudioProject: {
        __typename?: 'CrowdyStudioProject';
        projectId: string;
        appId: string;
        ownerUserId: string;
        gridId: string | null;
        name: string;
        description: string | null;
        serverModuleName: string | null;
        clientModuleName: string | null;
        pairingPreference: CrowdyStudioPairingPreference;
        sdkVersion: string;
        abiVersion: number;
        revision: string;
        archived: boolean;
        archivedAt: string | null;
        fileCount: number;
        totalBytes: string;
        createdAt: string;
        updatedAt: string;
        files: Array<{
            __typename?: 'CrowdyStudioProjectFile';
            target: CrowdyStudioTarget;
            path: string;
            content: string;
            revision: string;
            provenance: CrowdyStudioFileProvenance;
            provenanceLibraryFileId: string | null;
            provenanceLibraryRevision: string | null;
            provenanceCommonVersionId: string | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type CrowdyStudioProjectCreateMutationVariables = Exact<{
    input: CreateCrowdyStudioProjectInput;
}>;
export type CrowdyStudioProjectCreateMutation = {
    __typename?: 'Mutation';
    crowdyStudioProjectCreate: {
        __typename?: 'CrowdyStudioProject';
        projectId: string;
        appId: string;
        ownerUserId: string;
        gridId: string | null;
        name: string;
        description: string | null;
        serverModuleName: string | null;
        clientModuleName: string | null;
        pairingPreference: CrowdyStudioPairingPreference;
        sdkVersion: string;
        abiVersion: number;
        revision: string;
        archived: boolean;
        archivedAt: string | null;
        fileCount: number;
        totalBytes: string;
        createdAt: string;
        updatedAt: string;
        files: Array<{
            __typename?: 'CrowdyStudioProjectFile';
            target: CrowdyStudioTarget;
            path: string;
            content: string;
            revision: string;
            provenance: CrowdyStudioFileProvenance;
            provenanceLibraryFileId: string | null;
            provenanceLibraryRevision: string | null;
            provenanceCommonVersionId: string | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type CrowdyStudioProjectSaveMutationVariables = Exact<{
    input: SaveCrowdyStudioProjectInput;
}>;
export type CrowdyStudioProjectSaveMutation = {
    __typename?: 'Mutation';
    crowdyStudioProjectSave: {
        __typename?: 'CrowdyStudioProject';
        projectId: string;
        appId: string;
        ownerUserId: string;
        gridId: string | null;
        name: string;
        description: string | null;
        serverModuleName: string | null;
        clientModuleName: string | null;
        pairingPreference: CrowdyStudioPairingPreference;
        sdkVersion: string;
        abiVersion: number;
        revision: string;
        archived: boolean;
        archivedAt: string | null;
        fileCount: number;
        totalBytes: string;
        createdAt: string;
        updatedAt: string;
        files: Array<{
            __typename?: 'CrowdyStudioProjectFile';
            target: CrowdyStudioTarget;
            path: string;
            content: string;
            revision: string;
            provenance: CrowdyStudioFileProvenance;
            provenanceLibraryFileId: string | null;
            provenanceLibraryRevision: string | null;
            provenanceCommonVersionId: string | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type CrowdyStudioLibraryFilesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    includeArchived?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type CrowdyStudioLibraryFilesQuery = {
    __typename?: 'Query';
    crowdyStudioLibraryFiles: Array<{
        __typename?: 'CrowdyStudioLibraryFile';
        libraryFileId: string;
        appId: string;
        ownerUserId: string;
        title: string;
        pathHint: string;
        target: CrowdyStudioTarget;
        tags: Array<string>;
        content: string;
        revision: string;
        archived: boolean;
        archivedAt: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type CrowdyStudioLibrarySaveMutationVariables = Exact<{
    input: SaveCrowdyStudioLibraryFileInput;
}>;
export type CrowdyStudioLibrarySaveMutation = {
    __typename?: 'Mutation';
    crowdyStudioLibrarySave: {
        __typename?: 'CrowdyStudioLibraryFile';
        libraryFileId: string;
        appId: string;
        ownerUserId: string;
        title: string;
        pathHint: string;
        target: CrowdyStudioTarget;
        tags: Array<string>;
        content: string;
        revision: string;
        archived: boolean;
        archivedAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type CrowdyStudioCommonFilesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    target?: InputMaybe<CrowdyStudioTarget>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type CrowdyStudioCommonFilesQuery = {
    __typename?: 'Query';
    crowdyStudioCommonFiles: Array<{
        __typename?: 'CrowdyStudioCommonFile';
        commonFileId: string;
        appId: string;
        slug: string;
        title: string;
        description: string | null;
        path: string;
        target: CrowdyStudioTarget;
        tags: Array<string>;
        status: CrowdyStudioCommonStatus;
        versionId: string;
        versionNo: string;
        content: string;
        contentSha256: string;
        publishedByUserId: string;
        publishedAt: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type CrowdyStudioProjectImportFileMutationVariables = Exact<{
    input: ImportCrowdyStudioProjectFileInput;
}>;
export type CrowdyStudioProjectImportFileMutation = {
    __typename?: 'Mutation';
    crowdyStudioProjectImportFile: {
        __typename?: 'CrowdyStudioProject';
        projectId: string;
        appId: string;
        ownerUserId: string;
        gridId: string | null;
        name: string;
        description: string | null;
        serverModuleName: string | null;
        clientModuleName: string | null;
        pairingPreference: CrowdyStudioPairingPreference;
        sdkVersion: string;
        abiVersion: number;
        revision: string;
        archived: boolean;
        archivedAt: string | null;
        fileCount: number;
        totalBytes: string;
        createdAt: string;
        updatedAt: string;
        files: Array<{
            __typename?: 'CrowdyStudioProjectFile';
            target: CrowdyStudioTarget;
            path: string;
            content: string;
            revision: string;
            provenance: CrowdyStudioFileProvenance;
            provenanceLibraryFileId: string | null;
            provenanceLibraryRevision: string | null;
            provenanceCommonVersionId: string | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type CrowdyAgentErrorFieldsFragment = {
    __typename?: 'AgentError';
    code: string;
    message: string;
    retryable: boolean;
    remediation: string | null;
    field: string | null;
    requiredScope: string | null;
};
export type CrowdyAgentRunFieldsFragment = {
    __typename?: 'AgentRun';
    runId: string;
    status: CrowdyStudioAgentRunStatus;
    providerRounds: number;
    toolCalls: number;
    errorCode: string | null;
    terminalReason: string | null;
    reason: string | null;
    startedAt: string | null;
    finishedAt: string | null;
    createdAt: string;
    cancelled: boolean;
};
export type CrowdyAgentLeaseFieldsFragment = {
    __typename?: 'AgentLease';
    leaseId: string;
    kind: CrowdyStudioAgentLeaseType;
    status: CrowdyStudioAgentLeaseStatus;
    clientEpoch: string;
    scopes: Array<string>;
    holder: string;
    contextVersion: string;
    controlledEntityId: string | null;
    hostCapabilityRevision: string | null;
    expectedProjectRevision: string | null;
    grantedAt: string;
    expiresAt: string;
    revokedReason: string | null;
};
export type CrowdyAgentApprovalFieldsFragment = {
    __typename?: 'AgentApproval';
    approvalId: string;
    toolCallId: string;
    argumentHash: string;
    status: CrowdyStudioAgentApprovalStatus;
    safeSummary: string;
    clientEpoch: string;
    expiresAt: string;
    approved: boolean;
    rejected: boolean;
};
export type CrowdyAgentSessionFieldsFragment = {
    __typename?: 'AgentSession';
    contractVersion: string;
    sessionId: string;
    appId: string;
    projectId: string | null;
    gridId: string | null;
    mode: CrowdyStudioAgentMode;
    requestedModel: string;
    model: string | null;
    resolvedModel: string | null;
    status: CrowdyStudioAgentSessionStatus;
    providerDataConsent: boolean;
    registryDigest: string;
    providerPolicyVersion: string;
    appPolicyVersion: string;
    contextVersion: string;
    currentClientEpoch: string;
    clientEpoch: string | null;
    lastEventSeq: string;
    createdAt: string;
    updatedAt: string;
    closedAt: string | null;
    currentRun: {
        __typename?: 'AgentRun';
        runId: string;
        status: CrowdyStudioAgentRunStatus;
        providerRounds: number;
        toolCalls: number;
        errorCode: string | null;
        terminalReason: string | null;
        reason: string | null;
        startedAt: string | null;
        finishedAt: string | null;
        createdAt: string;
        cancelled: boolean;
    } | null;
    activeLeases: Array<{
        __typename?: 'AgentLease';
        leaseId: string;
        kind: CrowdyStudioAgentLeaseType;
        status: CrowdyStudioAgentLeaseStatus;
        clientEpoch: string;
        scopes: Array<string>;
        holder: string;
        contextVersion: string;
        controlledEntityId: string | null;
        hostCapabilityRevision: string | null;
        expectedProjectRevision: string | null;
        grantedAt: string;
        expiresAt: string;
        revokedReason: string | null;
    }>;
    pendingApproval: {
        __typename?: 'AgentApproval';
        approvalId: string;
        toolCallId: string;
        argumentHash: string;
        status: CrowdyStudioAgentApprovalStatus;
        safeSummary: string;
        clientEpoch: string;
        expiresAt: string;
        approved: boolean;
        rejected: boolean;
    } | null;
};
export type CrowdyAgentBudgetFieldsFragment = {
    __typename?: 'AgentBudget';
    resetAt: string | null;
    platformFunded: boolean;
    payer: string;
    dimensions: Array<{
        __typename?: 'AgentBudgetDimension';
        name: string;
        scope: string;
        limit: string;
        reserved: string;
        consumed: string;
        remaining: string;
        unit: string;
    }>;
};
export type CrowdyAgentToolDescriptorFieldsFragment = {
    __typename?: 'AgentToolDescriptor';
    schemaVersion: string;
    name: string;
    wireName: string;
    version: string;
    summary: string;
    executor: CrowdyStudioAgentToolExecutor;
    modes: Array<CrowdyStudioAgentMode>;
    risk: CrowdyStudioAgentToolRisk;
    riskEffects: Array<string>;
    riskReversible: boolean;
    scopes: Array<string>;
    scopeRequirementsJson: string;
    approvalRequired: boolean;
    approvalPolicy: string;
    approvalReasons: Array<string>;
    approvalMaxTtlSeconds: number;
    idempotencyClass: string;
    idempotencyKeyScope: string;
    timeoutMs: number;
    inputSchemaJson: string;
    outputSchemaJson: string;
    inputRedactionJson: string;
    outputRedactionJson: string;
    maxPersistedBytes: number;
    descriptorJson: string;
    descriptorDigest: string;
};
type CrowdyAgentEventBaseFields_AgentApprovalEvent_Fragment = {
    __typename?: 'AgentApprovalEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentBudgetEvent_Fragment = {
    __typename?: 'AgentBudgetEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentCheckpointEvent_Fragment = {
    __typename?: 'AgentCheckpointEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentLeaseEvent_Fragment = {
    __typename?: 'AgentLeaseEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentLifecycleEvent_Fragment = {
    __typename?: 'AgentLifecycleEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentMessageEvent_Fragment = {
    __typename?: 'AgentMessageEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentRunEvent_Fragment = {
    __typename?: 'AgentRunEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
type CrowdyAgentEventBaseFields_AgentToolEvent_Fragment = {
    __typename?: 'AgentToolEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
};
export type CrowdyAgentEventBaseFieldsFragment = CrowdyAgentEventBaseFields_AgentApprovalEvent_Fragment | CrowdyAgentEventBaseFields_AgentBudgetEvent_Fragment | CrowdyAgentEventBaseFields_AgentCheckpointEvent_Fragment | CrowdyAgentEventBaseFields_AgentLeaseEvent_Fragment | CrowdyAgentEventBaseFields_AgentLifecycleEvent_Fragment | CrowdyAgentEventBaseFields_AgentMessageEvent_Fragment | CrowdyAgentEventBaseFields_AgentRunEvent_Fragment | CrowdyAgentEventBaseFields_AgentToolEvent_Fragment;
type CrowdyAgentEventFields_AgentApprovalEvent_Fragment = {
    __typename: 'AgentApprovalEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    approvalEventId: string;
    approvalToolCallId: string;
    approvalArgumentHash: string;
    approvalStatus: CrowdyStudioAgentApprovalStatus;
    approvalSafeSummary: string;
    approvalReasons: Array<string>;
    approvalExpiresAt: string;
};
type CrowdyAgentEventFields_AgentBudgetEvent_Fragment = {
    __typename: 'AgentBudgetEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    budgetSnapshot: {
        __typename?: 'AgentBudget';
        resetAt: string | null;
        platformFunded: boolean;
        payer: string;
        dimensions: Array<{
            __typename?: 'AgentBudgetDimension';
            name: string;
            scope: string;
            limit: string;
            reserved: string;
            consumed: string;
            remaining: string;
            unit: string;
        }>;
    };
};
type CrowdyAgentEventFields_AgentCheckpointEvent_Fragment = {
    __typename: 'AgentCheckpointEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    checkpointEventId: string;
    checkpointProjectRevision: string;
    checkpointContentHash: string;
    checkpointReason: string;
    checkpointRestoredAt: string | null;
    checkpointFiles: Array<{
        __typename?: 'AgentCheckpointFile';
        target: string;
        path: string;
        contentHash: string;
        byteLength: number;
    }>;
};
type CrowdyAgentEventFields_AgentLeaseEvent_Fragment = {
    __typename: 'AgentLeaseEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    leaseEventId: string;
    leaseKind: CrowdyStudioAgentLeaseType;
    leaseStatus: CrowdyStudioAgentLeaseStatus;
    leaseClientEpoch: string;
    leaseScopes: Array<string>;
    leaseHolder: string;
    leaseContextVersion: string;
    leaseControlledEntityId: string | null;
    leaseHostCapabilityRevision: string | null;
    leaseExpectedProjectRevision: string | null;
    leaseGrantedAt: string;
    leaseExpiresAt: string;
    leaseReason: string | null;
};
type CrowdyAgentEventFields_AgentLifecycleEvent_Fragment = {
    __typename: 'AgentLifecycleEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    lifecycleMode: CrowdyStudioAgentMode | null;
    lifecycleClientEpoch: string | null;
    lifecycleReplayAfterSeq: string | null;
    lifecycleReason: string | null;
    lifecycleContextVersion: string | null;
};
type CrowdyAgentEventFields_AgentMessageEvent_Fragment = {
    __typename: 'AgentMessageEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    messageEventId: string;
    messageRole: string;
    messageContent: string;
};
type CrowdyAgentEventFields_AgentRunEvent_Fragment = {
    __typename: 'AgentRunEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    runStatus: CrowdyStudioAgentRunStatus;
    runCode: string | null;
    runReason: string | null;
    runError: {
        __typename?: 'AgentError';
        code: string;
        message: string;
        retryable: boolean;
        remediation: string | null;
        field: string | null;
        requiredScope: string | null;
    } | null;
};
type CrowdyAgentEventFields_AgentToolEvent_Fragment = {
    __typename: 'AgentToolEvent';
    protocolVersion: string;
    eventId: string;
    sessionId: string;
    seq: string;
    type: CrowdyStudioAgentEventType;
    runId: string | null;
    version: string;
    createdAt: string;
    toolEventCallId: string;
    toolEventName: string;
    toolEventVersion: string;
    toolStatus: CrowdyStudioAgentToolCallStatus;
    toolSafeSummary: string | null;
    toolDescriptorDigest: string | null;
    toolArgumentHash: string | null;
    toolExecutor: CrowdyStudioAgentToolExecutor | null;
    toolContextVersion: string | null;
    toolClientEpoch: string | null;
    toolArgumentsJson: string | null;
    toolLeaseId: string | null;
    toolApprovalGrant: string | null;
    toolIdempotencyKey: string | null;
    toolResultJson: string | null;
    toolDeadline: string | null;
    toolInvocation: {
        __typename?: 'AgentToolInvocation';
        protocolVersion: string;
        sessionId: string;
        runId: string;
        toolCallId: string;
        name: string;
        version: string;
        descriptorDigest: string;
        argumentsJson: string;
        argumentHash: string;
        contextVersion: string;
        clientEpoch: string | null;
        leaseId: string | null;
        approvalGrant: string | null;
        idempotencyKey: string | null;
        deadline: string;
    } | null;
    toolResult: {
        __typename?: 'AgentToolResultEnvelope';
        protocolVersion: string;
        toolCallId: string;
        status: CrowdyStudioAgentToolResultStatus;
        outputJson: string | null;
        observedContextVersion: string;
        startedAt: string;
        finishedAt: string;
        error: {
            __typename?: 'AgentError';
            code: string;
            message: string;
            retryable: boolean;
            remediation: string | null;
            field: string | null;
            requiredScope: string | null;
        } | null;
    } | null;
    toolError: {
        __typename?: 'AgentError';
        code: string;
        message: string;
        retryable: boolean;
        remediation: string | null;
        field: string | null;
        requiredScope: string | null;
    } | null;
};
export type CrowdyAgentEventFieldsFragment = CrowdyAgentEventFields_AgentApprovalEvent_Fragment | CrowdyAgentEventFields_AgentBudgetEvent_Fragment | CrowdyAgentEventFields_AgentCheckpointEvent_Fragment | CrowdyAgentEventFields_AgentLeaseEvent_Fragment | CrowdyAgentEventFields_AgentLifecycleEvent_Fragment | CrowdyAgentEventFields_AgentMessageEvent_Fragment | CrowdyAgentEventFields_AgentRunEvent_Fragment | CrowdyAgentEventFields_AgentToolEvent_Fragment;
export type CrowdyStudioAgentSessionQueryVariables = Exact<{
    sessionId: Scalars['String']['input'];
}>;
export type CrowdyStudioAgentSessionQuery = {
    __typename?: 'Query';
    crowdyStudioAgentSession: {
        __typename?: 'AgentSession';
        contractVersion: string;
        sessionId: string;
        appId: string;
        projectId: string | null;
        gridId: string | null;
        mode: CrowdyStudioAgentMode;
        requestedModel: string;
        model: string | null;
        resolvedModel: string | null;
        status: CrowdyStudioAgentSessionStatus;
        providerDataConsent: boolean;
        registryDigest: string;
        providerPolicyVersion: string;
        appPolicyVersion: string;
        contextVersion: string;
        currentClientEpoch: string;
        clientEpoch: string | null;
        lastEventSeq: string;
        createdAt: string;
        updatedAt: string;
        closedAt: string | null;
        currentRun: {
            __typename?: 'AgentRun';
            runId: string;
            status: CrowdyStudioAgentRunStatus;
            providerRounds: number;
            toolCalls: number;
            errorCode: string | null;
            terminalReason: string | null;
            reason: string | null;
            startedAt: string | null;
            finishedAt: string | null;
            createdAt: string;
            cancelled: boolean;
        } | null;
        activeLeases: Array<{
            __typename?: 'AgentLease';
            leaseId: string;
            kind: CrowdyStudioAgentLeaseType;
            status: CrowdyStudioAgentLeaseStatus;
            clientEpoch: string;
            scopes: Array<string>;
            holder: string;
            contextVersion: string;
            controlledEntityId: string | null;
            hostCapabilityRevision: string | null;
            expectedProjectRevision: string | null;
            grantedAt: string;
            expiresAt: string;
            revokedReason: string | null;
        }>;
        pendingApproval: {
            __typename?: 'AgentApproval';
            approvalId: string;
            toolCallId: string;
            argumentHash: string;
            status: CrowdyStudioAgentApprovalStatus;
            safeSummary: string;
            clientEpoch: string;
            expiresAt: string;
            approved: boolean;
            rejected: boolean;
        } | null;
    };
};
export type CrowdyStudioAgentSessionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    after?: InputMaybe<Scalars['String']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
}>;
export type CrowdyStudioAgentSessionsQuery = {
    __typename?: 'Query';
    crowdyStudioAgentSessions: {
        __typename?: 'AgentSessionConnection';
        endCursor: string | null;
        hasNextPage: boolean;
        edges: Array<{
            __typename?: 'AgentSessionEdge';
            cursor: string;
            node: {
                __typename?: 'AgentSession';
                contractVersion: string;
                sessionId: string;
                appId: string;
                projectId: string | null;
                gridId: string | null;
                mode: CrowdyStudioAgentMode;
                requestedModel: string;
                model: string | null;
                resolvedModel: string | null;
                status: CrowdyStudioAgentSessionStatus;
                providerDataConsent: boolean;
                registryDigest: string;
                providerPolicyVersion: string;
                appPolicyVersion: string;
                contextVersion: string;
                currentClientEpoch: string;
                clientEpoch: string | null;
                lastEventSeq: string;
                createdAt: string;
                updatedAt: string;
                closedAt: string | null;
                currentRun: {
                    __typename?: 'AgentRun';
                    runId: string;
                    status: CrowdyStudioAgentRunStatus;
                    providerRounds: number;
                    toolCalls: number;
                    errorCode: string | null;
                    terminalReason: string | null;
                    reason: string | null;
                    startedAt: string | null;
                    finishedAt: string | null;
                    createdAt: string;
                    cancelled: boolean;
                } | null;
                activeLeases: Array<{
                    __typename?: 'AgentLease';
                    leaseId: string;
                    kind: CrowdyStudioAgentLeaseType;
                    status: CrowdyStudioAgentLeaseStatus;
                    clientEpoch: string;
                    scopes: Array<string>;
                    holder: string;
                    contextVersion: string;
                    controlledEntityId: string | null;
                    hostCapabilityRevision: string | null;
                    expectedProjectRevision: string | null;
                    grantedAt: string;
                    expiresAt: string;
                    revokedReason: string | null;
                }>;
                pendingApproval: {
                    __typename?: 'AgentApproval';
                    approvalId: string;
                    toolCallId: string;
                    argumentHash: string;
                    status: CrowdyStudioAgentApprovalStatus;
                    safeSummary: string;
                    clientEpoch: string;
                    expiresAt: string;
                    approved: boolean;
                    rejected: boolean;
                } | null;
            };
        }>;
        pageInfo: {
            __typename?: 'AgentPageInfo';
            hasNextPage: boolean;
            endCursor: string | null;
        };
        nodes: Array<{
            __typename?: 'AgentSession';
            contractVersion: string;
            sessionId: string;
            appId: string;
            projectId: string | null;
            gridId: string | null;
            mode: CrowdyStudioAgentMode;
            requestedModel: string;
            model: string | null;
            resolvedModel: string | null;
            status: CrowdyStudioAgentSessionStatus;
            providerDataConsent: boolean;
            registryDigest: string;
            providerPolicyVersion: string;
            appPolicyVersion: string;
            contextVersion: string;
            currentClientEpoch: string;
            clientEpoch: string | null;
            lastEventSeq: string;
            createdAt: string;
            updatedAt: string;
            closedAt: string | null;
            currentRun: {
                __typename?: 'AgentRun';
                runId: string;
                status: CrowdyStudioAgentRunStatus;
                providerRounds: number;
                toolCalls: number;
                errorCode: string | null;
                terminalReason: string | null;
                reason: string | null;
                startedAt: string | null;
                finishedAt: string | null;
                createdAt: string;
                cancelled: boolean;
            } | null;
            activeLeases: Array<{
                __typename?: 'AgentLease';
                leaseId: string;
                kind: CrowdyStudioAgentLeaseType;
                status: CrowdyStudioAgentLeaseStatus;
                clientEpoch: string;
                scopes: Array<string>;
                holder: string;
                contextVersion: string;
                controlledEntityId: string | null;
                hostCapabilityRevision: string | null;
                expectedProjectRevision: string | null;
                grantedAt: string;
                expiresAt: string;
                revokedReason: string | null;
            }>;
            pendingApproval: {
                __typename?: 'AgentApproval';
                approvalId: string;
                toolCallId: string;
                argumentHash: string;
                status: CrowdyStudioAgentApprovalStatus;
                safeSummary: string;
                clientEpoch: string;
                expiresAt: string;
                approved: boolean;
                rejected: boolean;
            } | null;
        }>;
    };
};
export type CrowdyStudioAgentHistoryQueryVariables = Exact<{
    sessionId: Scalars['String']['input'];
    afterSeq?: InputMaybe<Scalars['BigInt']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
}>;
export type CrowdyStudioAgentHistoryQuery = {
    __typename?: 'Query';
    crowdyStudioAgentHistory: {
        __typename?: 'AgentEventConnection';
        hasMore: boolean;
        edges: Array<{
            __typename?: 'AgentEventEdge';
            cursor: string;
            node: {
                __typename: 'AgentApprovalEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                approvalEventId: string;
                approvalToolCallId: string;
                approvalArgumentHash: string;
                approvalStatus: CrowdyStudioAgentApprovalStatus;
                approvalSafeSummary: string;
                approvalReasons: Array<string>;
                approvalExpiresAt: string;
            } | {
                __typename: 'AgentBudgetEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                budgetSnapshot: {
                    __typename?: 'AgentBudget';
                    resetAt: string | null;
                    platformFunded: boolean;
                    payer: string;
                    dimensions: Array<{
                        __typename?: 'AgentBudgetDimension';
                        name: string;
                        scope: string;
                        limit: string;
                        reserved: string;
                        consumed: string;
                        remaining: string;
                        unit: string;
                    }>;
                };
            } | {
                __typename: 'AgentCheckpointEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                checkpointEventId: string;
                checkpointProjectRevision: string;
                checkpointContentHash: string;
                checkpointReason: string;
                checkpointRestoredAt: string | null;
                checkpointFiles: Array<{
                    __typename?: 'AgentCheckpointFile';
                    target: string;
                    path: string;
                    contentHash: string;
                    byteLength: number;
                }>;
            } | {
                __typename: 'AgentLeaseEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                leaseEventId: string;
                leaseKind: CrowdyStudioAgentLeaseType;
                leaseStatus: CrowdyStudioAgentLeaseStatus;
                leaseClientEpoch: string;
                leaseScopes: Array<string>;
                leaseHolder: string;
                leaseContextVersion: string;
                leaseControlledEntityId: string | null;
                leaseHostCapabilityRevision: string | null;
                leaseExpectedProjectRevision: string | null;
                leaseGrantedAt: string;
                leaseExpiresAt: string;
                leaseReason: string | null;
            } | {
                __typename: 'AgentLifecycleEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                lifecycleMode: CrowdyStudioAgentMode | null;
                lifecycleClientEpoch: string | null;
                lifecycleReplayAfterSeq: string | null;
                lifecycleReason: string | null;
                lifecycleContextVersion: string | null;
            } | {
                __typename: 'AgentMessageEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                messageEventId: string;
                messageRole: string;
                messageContent: string;
            } | {
                __typename: 'AgentRunEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                runStatus: CrowdyStudioAgentRunStatus;
                runCode: string | null;
                runReason: string | null;
                runError: {
                    __typename?: 'AgentError';
                    code: string;
                    message: string;
                    retryable: boolean;
                    remediation: string | null;
                    field: string | null;
                    requiredScope: string | null;
                } | null;
            } | {
                __typename: 'AgentToolEvent';
                protocolVersion: string;
                eventId: string;
                sessionId: string;
                seq: string;
                type: CrowdyStudioAgentEventType;
                runId: string | null;
                version: string;
                createdAt: string;
                toolEventCallId: string;
                toolEventName: string;
                toolEventVersion: string;
                toolStatus: CrowdyStudioAgentToolCallStatus;
                toolSafeSummary: string | null;
                toolDescriptorDigest: string | null;
                toolArgumentHash: string | null;
                toolExecutor: CrowdyStudioAgentToolExecutor | null;
                toolContextVersion: string | null;
                toolClientEpoch: string | null;
                toolArgumentsJson: string | null;
                toolLeaseId: string | null;
                toolApprovalGrant: string | null;
                toolIdempotencyKey: string | null;
                toolResultJson: string | null;
                toolDeadline: string | null;
                toolInvocation: {
                    __typename?: 'AgentToolInvocation';
                    protocolVersion: string;
                    sessionId: string;
                    runId: string;
                    toolCallId: string;
                    name: string;
                    version: string;
                    descriptorDigest: string;
                    argumentsJson: string;
                    argumentHash: string;
                    contextVersion: string;
                    clientEpoch: string | null;
                    leaseId: string | null;
                    approvalGrant: string | null;
                    idempotencyKey: string | null;
                    deadline: string;
                } | null;
                toolResult: {
                    __typename?: 'AgentToolResultEnvelope';
                    protocolVersion: string;
                    toolCallId: string;
                    status: CrowdyStudioAgentToolResultStatus;
                    outputJson: string | null;
                    observedContextVersion: string;
                    startedAt: string;
                    finishedAt: string;
                    error: {
                        __typename?: 'AgentError';
                        code: string;
                        message: string;
                        retryable: boolean;
                        remediation: string | null;
                        field: string | null;
                        requiredScope: string | null;
                    } | null;
                } | null;
                toolError: {
                    __typename?: 'AgentError';
                    code: string;
                    message: string;
                    retryable: boolean;
                    remediation: string | null;
                    field: string | null;
                    requiredScope: string | null;
                } | null;
            };
        }>;
        pageInfo: {
            __typename?: 'AgentPageInfo';
            hasNextPage: boolean;
            endCursor: string | null;
        };
        events: Array<{
            __typename: 'AgentApprovalEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            approvalEventId: string;
            approvalToolCallId: string;
            approvalArgumentHash: string;
            approvalStatus: CrowdyStudioAgentApprovalStatus;
            approvalSafeSummary: string;
            approvalReasons: Array<string>;
            approvalExpiresAt: string;
        } | {
            __typename: 'AgentBudgetEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            budgetSnapshot: {
                __typename?: 'AgentBudget';
                resetAt: string | null;
                platformFunded: boolean;
                payer: string;
                dimensions: Array<{
                    __typename?: 'AgentBudgetDimension';
                    name: string;
                    scope: string;
                    limit: string;
                    reserved: string;
                    consumed: string;
                    remaining: string;
                    unit: string;
                }>;
            };
        } | {
            __typename: 'AgentCheckpointEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            checkpointEventId: string;
            checkpointProjectRevision: string;
            checkpointContentHash: string;
            checkpointReason: string;
            checkpointRestoredAt: string | null;
            checkpointFiles: Array<{
                __typename?: 'AgentCheckpointFile';
                target: string;
                path: string;
                contentHash: string;
                byteLength: number;
            }>;
        } | {
            __typename: 'AgentLeaseEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            leaseEventId: string;
            leaseKind: CrowdyStudioAgentLeaseType;
            leaseStatus: CrowdyStudioAgentLeaseStatus;
            leaseClientEpoch: string;
            leaseScopes: Array<string>;
            leaseHolder: string;
            leaseContextVersion: string;
            leaseControlledEntityId: string | null;
            leaseHostCapabilityRevision: string | null;
            leaseExpectedProjectRevision: string | null;
            leaseGrantedAt: string;
            leaseExpiresAt: string;
            leaseReason: string | null;
        } | {
            __typename: 'AgentLifecycleEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            lifecycleMode: CrowdyStudioAgentMode | null;
            lifecycleClientEpoch: string | null;
            lifecycleReplayAfterSeq: string | null;
            lifecycleReason: string | null;
            lifecycleContextVersion: string | null;
        } | {
            __typename: 'AgentMessageEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            messageEventId: string;
            messageRole: string;
            messageContent: string;
        } | {
            __typename: 'AgentRunEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            runStatus: CrowdyStudioAgentRunStatus;
            runCode: string | null;
            runReason: string | null;
            runError: {
                __typename?: 'AgentError';
                code: string;
                message: string;
                retryable: boolean;
                remediation: string | null;
                field: string | null;
                requiredScope: string | null;
            } | null;
        } | {
            __typename: 'AgentToolEvent';
            protocolVersion: string;
            eventId: string;
            sessionId: string;
            seq: string;
            type: CrowdyStudioAgentEventType;
            runId: string | null;
            version: string;
            createdAt: string;
            toolEventCallId: string;
            toolEventName: string;
            toolEventVersion: string;
            toolStatus: CrowdyStudioAgentToolCallStatus;
            toolSafeSummary: string | null;
            toolDescriptorDigest: string | null;
            toolArgumentHash: string | null;
            toolExecutor: CrowdyStudioAgentToolExecutor | null;
            toolContextVersion: string | null;
            toolClientEpoch: string | null;
            toolArgumentsJson: string | null;
            toolLeaseId: string | null;
            toolApprovalGrant: string | null;
            toolIdempotencyKey: string | null;
            toolResultJson: string | null;
            toolDeadline: string | null;
            toolInvocation: {
                __typename?: 'AgentToolInvocation';
                protocolVersion: string;
                sessionId: string;
                runId: string;
                toolCallId: string;
                name: string;
                version: string;
                descriptorDigest: string;
                argumentsJson: string;
                argumentHash: string;
                contextVersion: string;
                clientEpoch: string | null;
                leaseId: string | null;
                approvalGrant: string | null;
                idempotencyKey: string | null;
                deadline: string;
            } | null;
            toolResult: {
                __typename?: 'AgentToolResultEnvelope';
                protocolVersion: string;
                toolCallId: string;
                status: CrowdyStudioAgentToolResultStatus;
                outputJson: string | null;
                observedContextVersion: string;
                startedAt: string;
                finishedAt: string;
                error: {
                    __typename?: 'AgentError';
                    code: string;
                    message: string;
                    retryable: boolean;
                    remediation: string | null;
                    field: string | null;
                    requiredScope: string | null;
                } | null;
            } | null;
            toolError: {
                __typename?: 'AgentError';
                code: string;
                message: string;
                retryable: boolean;
                remediation: string | null;
                field: string | null;
                requiredScope: string | null;
            } | null;
        }>;
    };
};
export type CrowdyStudioAgentToolDescriptorsQueryVariables = Exact<{
    sessionId: Scalars['String']['input'];
}>;
export type CrowdyStudioAgentToolDescriptorsQuery = {
    __typename?: 'Query';
    crowdyStudioAgentToolDescriptors: {
        __typename?: 'AgentToolDescriptorSet';
        registryDigest: string;
        tools: Array<{
            __typename?: 'AgentToolDescriptor';
            schemaVersion: string;
            name: string;
            wireName: string;
            version: string;
            summary: string;
            executor: CrowdyStudioAgentToolExecutor;
            modes: Array<CrowdyStudioAgentMode>;
            risk: CrowdyStudioAgentToolRisk;
            riskEffects: Array<string>;
            riskReversible: boolean;
            scopes: Array<string>;
            scopeRequirementsJson: string;
            approvalRequired: boolean;
            approvalPolicy: string;
            approvalReasons: Array<string>;
            approvalMaxTtlSeconds: number;
            idempotencyClass: string;
            idempotencyKeyScope: string;
            timeoutMs: number;
            inputSchemaJson: string;
            outputSchemaJson: string;
            inputRedactionJson: string;
            outputRedactionJson: string;
            maxPersistedBytes: number;
            descriptorJson: string;
            descriptorDigest: string;
        }>;
    };
};
export type CrowdyStudioAgentBudgetQueryVariables = Exact<{
    sessionId: Scalars['String']['input'];
}>;
export type CrowdyStudioAgentBudgetQuery = {
    __typename?: 'Query';
    crowdyStudioAgentBudget: {
        __typename?: 'AgentBudget';
        resetAt: string | null;
        platformFunded: boolean;
        payer: string;
        dimensions: Array<{
            __typename?: 'AgentBudgetDimension';
            name: string;
            scope: string;
            limit: string;
            reserved: string;
            consumed: string;
            remaining: string;
            unit: string;
        }>;
    };
};
export type CrowdyStudioAgentCreateSessionMutationVariables = Exact<{
    input: CreateAgentSessionInput;
}>;
export type CrowdyStudioAgentCreateSessionMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentCreateSession: {
        __typename?: 'AgentSession';
        contractVersion: string;
        sessionId: string;
        appId: string;
        projectId: string | null;
        gridId: string | null;
        mode: CrowdyStudioAgentMode;
        requestedModel: string;
        model: string | null;
        resolvedModel: string | null;
        status: CrowdyStudioAgentSessionStatus;
        providerDataConsent: boolean;
        registryDigest: string;
        providerPolicyVersion: string;
        appPolicyVersion: string;
        contextVersion: string;
        currentClientEpoch: string;
        clientEpoch: string | null;
        lastEventSeq: string;
        createdAt: string;
        updatedAt: string;
        closedAt: string | null;
        currentRun: {
            __typename?: 'AgentRun';
            runId: string;
            status: CrowdyStudioAgentRunStatus;
            providerRounds: number;
            toolCalls: number;
            errorCode: string | null;
            terminalReason: string | null;
            reason: string | null;
            startedAt: string | null;
            finishedAt: string | null;
            createdAt: string;
            cancelled: boolean;
        } | null;
        activeLeases: Array<{
            __typename?: 'AgentLease';
            leaseId: string;
            kind: CrowdyStudioAgentLeaseType;
            status: CrowdyStudioAgentLeaseStatus;
            clientEpoch: string;
            scopes: Array<string>;
            holder: string;
            contextVersion: string;
            controlledEntityId: string | null;
            hostCapabilityRevision: string | null;
            expectedProjectRevision: string | null;
            grantedAt: string;
            expiresAt: string;
            revokedReason: string | null;
        }>;
        pendingApproval: {
            __typename?: 'AgentApproval';
            approvalId: string;
            toolCallId: string;
            argumentHash: string;
            status: CrowdyStudioAgentApprovalStatus;
            safeSummary: string;
            clientEpoch: string;
            expiresAt: string;
            approved: boolean;
            rejected: boolean;
        } | null;
    };
};
export type CrowdyStudioAgentAttachClientMutationVariables = Exact<{
    input: AttachAgentClientInput;
}>;
export type CrowdyStudioAgentAttachClientMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentAttachClient: {
        __typename?: 'AgentClientAttachment';
        clientEpoch: string;
        replayAfterSeq: string;
        session: {
            __typename?: 'AgentSession';
            contractVersion: string;
            sessionId: string;
            appId: string;
            projectId: string | null;
            gridId: string | null;
            mode: CrowdyStudioAgentMode;
            requestedModel: string;
            model: string | null;
            resolvedModel: string | null;
            status: CrowdyStudioAgentSessionStatus;
            providerDataConsent: boolean;
            registryDigest: string;
            providerPolicyVersion: string;
            appPolicyVersion: string;
            contextVersion: string;
            currentClientEpoch: string;
            clientEpoch: string | null;
            lastEventSeq: string;
            createdAt: string;
            updatedAt: string;
            closedAt: string | null;
            currentRun: {
                __typename?: 'AgentRun';
                runId: string;
                status: CrowdyStudioAgentRunStatus;
                providerRounds: number;
                toolCalls: number;
                errorCode: string | null;
                terminalReason: string | null;
                reason: string | null;
                startedAt: string | null;
                finishedAt: string | null;
                createdAt: string;
                cancelled: boolean;
            } | null;
            activeLeases: Array<{
                __typename?: 'AgentLease';
                leaseId: string;
                kind: CrowdyStudioAgentLeaseType;
                status: CrowdyStudioAgentLeaseStatus;
                clientEpoch: string;
                scopes: Array<string>;
                holder: string;
                contextVersion: string;
                controlledEntityId: string | null;
                hostCapabilityRevision: string | null;
                expectedProjectRevision: string | null;
                grantedAt: string;
                expiresAt: string;
                revokedReason: string | null;
            }>;
            pendingApproval: {
                __typename?: 'AgentApproval';
                approvalId: string;
                toolCallId: string;
                argumentHash: string;
                status: CrowdyStudioAgentApprovalStatus;
                safeSummary: string;
                clientEpoch: string;
                expiresAt: string;
                approved: boolean;
                rejected: boolean;
            } | null;
        };
    };
};
export type CrowdyStudioAgentSetModeMutationVariables = Exact<{
    input: SetAgentModeInput;
}>;
export type CrowdyStudioAgentSetModeMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentSetMode: {
        __typename?: 'AgentSession';
        contractVersion: string;
        sessionId: string;
        appId: string;
        projectId: string | null;
        gridId: string | null;
        mode: CrowdyStudioAgentMode;
        requestedModel: string;
        model: string | null;
        resolvedModel: string | null;
        status: CrowdyStudioAgentSessionStatus;
        providerDataConsent: boolean;
        registryDigest: string;
        providerPolicyVersion: string;
        appPolicyVersion: string;
        contextVersion: string;
        currentClientEpoch: string;
        clientEpoch: string | null;
        lastEventSeq: string;
        createdAt: string;
        updatedAt: string;
        closedAt: string | null;
        currentRun: {
            __typename?: 'AgentRun';
            runId: string;
            status: CrowdyStudioAgentRunStatus;
            providerRounds: number;
            toolCalls: number;
            errorCode: string | null;
            terminalReason: string | null;
            reason: string | null;
            startedAt: string | null;
            finishedAt: string | null;
            createdAt: string;
            cancelled: boolean;
        } | null;
        activeLeases: Array<{
            __typename?: 'AgentLease';
            leaseId: string;
            kind: CrowdyStudioAgentLeaseType;
            status: CrowdyStudioAgentLeaseStatus;
            clientEpoch: string;
            scopes: Array<string>;
            holder: string;
            contextVersion: string;
            controlledEntityId: string | null;
            hostCapabilityRevision: string | null;
            expectedProjectRevision: string | null;
            grantedAt: string;
            expiresAt: string;
            revokedReason: string | null;
        }>;
        pendingApproval: {
            __typename?: 'AgentApproval';
            approvalId: string;
            toolCallId: string;
            argumentHash: string;
            status: CrowdyStudioAgentApprovalStatus;
            safeSummary: string;
            clientEpoch: string;
            expiresAt: string;
            approved: boolean;
            rejected: boolean;
        } | null;
    };
};
export type CrowdyStudioAgentAcknowledgeEventsMutationVariables = Exact<{
    input: AcknowledgeAgentEventsInput;
}>;
export type CrowdyStudioAgentAcknowledgeEventsMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentAcknowledgeEvents: {
        __typename?: 'AgentEventAcknowledgement';
        throughSeq: string;
    };
};
export type CrowdyStudioAgentHeartbeatMutationVariables = Exact<{
    input: AgentHeartbeatInput;
}>;
export type CrowdyStudioAgentHeartbeatMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentHeartbeat: {
        __typename?: 'AgentHeartbeat';
        serverTime: string;
        playLeaseFreshUntil: string | null;
        workspaceLeaseExpiresAt: string | null;
    };
};
export type CrowdyStudioAgentSendMessageMutationVariables = Exact<{
    input: SendAgentMessageInput;
}>;
export type CrowdyStudioAgentSendMessageMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentSendMessage: {
        __typename?: 'AgentRun';
        runId: string;
        status: CrowdyStudioAgentRunStatus;
        providerRounds: number;
        toolCalls: number;
        errorCode: string | null;
        terminalReason: string | null;
        reason: string | null;
        startedAt: string | null;
        finishedAt: string | null;
        createdAt: string;
        cancelled: boolean;
    };
};
export type CrowdyStudioAgentApproveToolMutationVariables = Exact<{
    input: DecideAgentToolInput;
}>;
export type CrowdyStudioAgentApproveToolMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentApproveTool: {
        __typename?: 'AgentApproval';
        approvalId: string;
        toolCallId: string;
        argumentHash: string;
        status: CrowdyStudioAgentApprovalStatus;
        safeSummary: string;
        clientEpoch: string;
        expiresAt: string;
        approved: boolean;
        rejected: boolean;
    };
};
export type CrowdyStudioAgentRejectToolMutationVariables = Exact<{
    input: DecideAgentToolInput;
}>;
export type CrowdyStudioAgentRejectToolMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentRejectTool: {
        __typename?: 'AgentApproval';
        approvalId: string;
        toolCallId: string;
        argumentHash: string;
        status: CrowdyStudioAgentApprovalStatus;
        safeSummary: string;
        clientEpoch: string;
        expiresAt: string;
        approved: boolean;
        rejected: boolean;
    };
};
export type CrowdyStudioAgentToolResultMutationVariables = Exact<{
    input: AgentToolResultInput;
}>;
export type CrowdyStudioAgentToolResultMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentToolResult: {
        __typename?: 'AgentToolCall';
        toolCallId: string;
        toolName: string;
        status: CrowdyStudioAgentToolCallStatus;
        argumentHash: string;
        accepted: boolean;
        error: {
            __typename?: 'AgentError';
            code: string;
            message: string;
            retryable: boolean;
            remediation: string | null;
            field: string | null;
            requiredScope: string | null;
        } | null;
    };
};
export type CrowdyStudioAgentGrantLeaseMutationVariables = Exact<{
    input: GrantAgentLeaseInput;
}>;
export type CrowdyStudioAgentGrantLeaseMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentGrantLease: {
        __typename?: 'AgentLease';
        leaseId: string;
        kind: CrowdyStudioAgentLeaseType;
        status: CrowdyStudioAgentLeaseStatus;
        clientEpoch: string;
        scopes: Array<string>;
        holder: string;
        contextVersion: string;
        controlledEntityId: string | null;
        hostCapabilityRevision: string | null;
        expectedProjectRevision: string | null;
        grantedAt: string;
        expiresAt: string;
        revokedReason: string | null;
    };
};
export type CrowdyStudioAgentRevokeLeaseMutationVariables = Exact<{
    input: RevokeAgentLeaseInput;
}>;
export type CrowdyStudioAgentRevokeLeaseMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentRevokeLease: {
        __typename?: 'AgentLease';
        leaseId: string;
        kind: CrowdyStudioAgentLeaseType;
        status: CrowdyStudioAgentLeaseStatus;
        clientEpoch: string;
        scopes: Array<string>;
        holder: string;
        contextVersion: string;
        controlledEntityId: string | null;
        hostCapabilityRevision: string | null;
        expectedProjectRevision: string | null;
        grantedAt: string;
        expiresAt: string;
        revokedReason: string | null;
    };
};
export type CrowdyStudioAgentPauseMutationVariables = Exact<{
    input: AgentSessionControlInput;
}>;
export type CrowdyStudioAgentPauseMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentPause: {
        __typename?: 'AgentSession';
        contractVersion: string;
        sessionId: string;
        appId: string;
        projectId: string | null;
        gridId: string | null;
        mode: CrowdyStudioAgentMode;
        requestedModel: string;
        model: string | null;
        resolvedModel: string | null;
        status: CrowdyStudioAgentSessionStatus;
        providerDataConsent: boolean;
        registryDigest: string;
        providerPolicyVersion: string;
        appPolicyVersion: string;
        contextVersion: string;
        currentClientEpoch: string;
        clientEpoch: string | null;
        lastEventSeq: string;
        createdAt: string;
        updatedAt: string;
        closedAt: string | null;
        currentRun: {
            __typename?: 'AgentRun';
            runId: string;
            status: CrowdyStudioAgentRunStatus;
            providerRounds: number;
            toolCalls: number;
            errorCode: string | null;
            terminalReason: string | null;
            reason: string | null;
            startedAt: string | null;
            finishedAt: string | null;
            createdAt: string;
            cancelled: boolean;
        } | null;
        activeLeases: Array<{
            __typename?: 'AgentLease';
            leaseId: string;
            kind: CrowdyStudioAgentLeaseType;
            status: CrowdyStudioAgentLeaseStatus;
            clientEpoch: string;
            scopes: Array<string>;
            holder: string;
            contextVersion: string;
            controlledEntityId: string | null;
            hostCapabilityRevision: string | null;
            expectedProjectRevision: string | null;
            grantedAt: string;
            expiresAt: string;
            revokedReason: string | null;
        }>;
        pendingApproval: {
            __typename?: 'AgentApproval';
            approvalId: string;
            toolCallId: string;
            argumentHash: string;
            status: CrowdyStudioAgentApprovalStatus;
            safeSummary: string;
            clientEpoch: string;
            expiresAt: string;
            approved: boolean;
            rejected: boolean;
        } | null;
    };
};
export type CrowdyStudioAgentResumeMutationVariables = Exact<{
    input: AgentSessionControlInput;
}>;
export type CrowdyStudioAgentResumeMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentResume: {
        __typename?: 'AgentSession';
        contractVersion: string;
        sessionId: string;
        appId: string;
        projectId: string | null;
        gridId: string | null;
        mode: CrowdyStudioAgentMode;
        requestedModel: string;
        model: string | null;
        resolvedModel: string | null;
        status: CrowdyStudioAgentSessionStatus;
        providerDataConsent: boolean;
        registryDigest: string;
        providerPolicyVersion: string;
        appPolicyVersion: string;
        contextVersion: string;
        currentClientEpoch: string;
        clientEpoch: string | null;
        lastEventSeq: string;
        createdAt: string;
        updatedAt: string;
        closedAt: string | null;
        currentRun: {
            __typename?: 'AgentRun';
            runId: string;
            status: CrowdyStudioAgentRunStatus;
            providerRounds: number;
            toolCalls: number;
            errorCode: string | null;
            terminalReason: string | null;
            reason: string | null;
            startedAt: string | null;
            finishedAt: string | null;
            createdAt: string;
            cancelled: boolean;
        } | null;
        activeLeases: Array<{
            __typename?: 'AgentLease';
            leaseId: string;
            kind: CrowdyStudioAgentLeaseType;
            status: CrowdyStudioAgentLeaseStatus;
            clientEpoch: string;
            scopes: Array<string>;
            holder: string;
            contextVersion: string;
            controlledEntityId: string | null;
            hostCapabilityRevision: string | null;
            expectedProjectRevision: string | null;
            grantedAt: string;
            expiresAt: string;
            revokedReason: string | null;
        }>;
        pendingApproval: {
            __typename?: 'AgentApproval';
            approvalId: string;
            toolCallId: string;
            argumentHash: string;
            status: CrowdyStudioAgentApprovalStatus;
            safeSummary: string;
            clientEpoch: string;
            expiresAt: string;
            approved: boolean;
            rejected: boolean;
        } | null;
    };
};
export type CrowdyStudioAgentCancelRunMutationVariables = Exact<{
    input: CancelAgentRunInput;
}>;
export type CrowdyStudioAgentCancelRunMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentCancelRun: {
        __typename?: 'AgentRun';
        runId: string;
        status: CrowdyStudioAgentRunStatus;
        providerRounds: number;
        toolCalls: number;
        errorCode: string | null;
        terminalReason: string | null;
        reason: string | null;
        startedAt: string | null;
        finishedAt: string | null;
        createdAt: string;
        cancelled: boolean;
    };
};
export type CrowdyStudioAgentCloseSessionMutationVariables = Exact<{
    input: AgentSessionControlInput;
}>;
export type CrowdyStudioAgentCloseSessionMutation = {
    __typename?: 'Mutation';
    crowdyStudioAgentCloseSession: {
        __typename?: 'AgentSession';
        contractVersion: string;
        sessionId: string;
        appId: string;
        projectId: string | null;
        gridId: string | null;
        mode: CrowdyStudioAgentMode;
        requestedModel: string;
        model: string | null;
        resolvedModel: string | null;
        status: CrowdyStudioAgentSessionStatus;
        providerDataConsent: boolean;
        registryDigest: string;
        providerPolicyVersion: string;
        appPolicyVersion: string;
        contextVersion: string;
        currentClientEpoch: string;
        clientEpoch: string | null;
        lastEventSeq: string;
        createdAt: string;
        updatedAt: string;
        closedAt: string | null;
        currentRun: {
            __typename?: 'AgentRun';
            runId: string;
            status: CrowdyStudioAgentRunStatus;
            providerRounds: number;
            toolCalls: number;
            errorCode: string | null;
            terminalReason: string | null;
            reason: string | null;
            startedAt: string | null;
            finishedAt: string | null;
            createdAt: string;
            cancelled: boolean;
        } | null;
        activeLeases: Array<{
            __typename?: 'AgentLease';
            leaseId: string;
            kind: CrowdyStudioAgentLeaseType;
            status: CrowdyStudioAgentLeaseStatus;
            clientEpoch: string;
            scopes: Array<string>;
            holder: string;
            contextVersion: string;
            controlledEntityId: string | null;
            hostCapabilityRevision: string | null;
            expectedProjectRevision: string | null;
            grantedAt: string;
            expiresAt: string;
            revokedReason: string | null;
        }>;
        pendingApproval: {
            __typename?: 'AgentApproval';
            approvalId: string;
            toolCallId: string;
            argumentHash: string;
            status: CrowdyStudioAgentApprovalStatus;
            safeSummary: string;
            clientEpoch: string;
            expiresAt: string;
            approved: boolean;
            rejected: boolean;
        } | null;
    };
};
export type CrowdyStudioAgentEventsSubscriptionVariables = Exact<{
    sessionId: Scalars['String']['input'];
    afterSeq: Scalars['BigInt']['input'];
    clientEpoch: Scalars['BigInt']['input'];
}>;
export type CrowdyStudioAgentEventsSubscription = {
    __typename?: 'Subscription';
    crowdyStudioAgentEvents: {
        __typename: 'AgentApprovalEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        approvalEventId: string;
        approvalToolCallId: string;
        approvalArgumentHash: string;
        approvalStatus: CrowdyStudioAgentApprovalStatus;
        approvalSafeSummary: string;
        approvalReasons: Array<string>;
        approvalExpiresAt: string;
    } | {
        __typename: 'AgentBudgetEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        budgetSnapshot: {
            __typename?: 'AgentBudget';
            resetAt: string | null;
            platformFunded: boolean;
            payer: string;
            dimensions: Array<{
                __typename?: 'AgentBudgetDimension';
                name: string;
                scope: string;
                limit: string;
                reserved: string;
                consumed: string;
                remaining: string;
                unit: string;
            }>;
        };
    } | {
        __typename: 'AgentCheckpointEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        checkpointEventId: string;
        checkpointProjectRevision: string;
        checkpointContentHash: string;
        checkpointReason: string;
        checkpointRestoredAt: string | null;
        checkpointFiles: Array<{
            __typename?: 'AgentCheckpointFile';
            target: string;
            path: string;
            contentHash: string;
            byteLength: number;
        }>;
    } | {
        __typename: 'AgentLeaseEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        leaseEventId: string;
        leaseKind: CrowdyStudioAgentLeaseType;
        leaseStatus: CrowdyStudioAgentLeaseStatus;
        leaseClientEpoch: string;
        leaseScopes: Array<string>;
        leaseHolder: string;
        leaseContextVersion: string;
        leaseControlledEntityId: string | null;
        leaseHostCapabilityRevision: string | null;
        leaseExpectedProjectRevision: string | null;
        leaseGrantedAt: string;
        leaseExpiresAt: string;
        leaseReason: string | null;
    } | {
        __typename: 'AgentLifecycleEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        lifecycleMode: CrowdyStudioAgentMode | null;
        lifecycleClientEpoch: string | null;
        lifecycleReplayAfterSeq: string | null;
        lifecycleReason: string | null;
        lifecycleContextVersion: string | null;
    } | {
        __typename: 'AgentMessageEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        messageEventId: string;
        messageRole: string;
        messageContent: string;
    } | {
        __typename: 'AgentRunEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        runStatus: CrowdyStudioAgentRunStatus;
        runCode: string | null;
        runReason: string | null;
        runError: {
            __typename?: 'AgentError';
            code: string;
            message: string;
            retryable: boolean;
            remediation: string | null;
            field: string | null;
            requiredScope: string | null;
        } | null;
    } | {
        __typename: 'AgentToolEvent';
        protocolVersion: string;
        eventId: string;
        sessionId: string;
        seq: string;
        type: CrowdyStudioAgentEventType;
        runId: string | null;
        version: string;
        createdAt: string;
        toolEventCallId: string;
        toolEventName: string;
        toolEventVersion: string;
        toolStatus: CrowdyStudioAgentToolCallStatus;
        toolSafeSummary: string | null;
        toolDescriptorDigest: string | null;
        toolArgumentHash: string | null;
        toolExecutor: CrowdyStudioAgentToolExecutor | null;
        toolContextVersion: string | null;
        toolClientEpoch: string | null;
        toolArgumentsJson: string | null;
        toolLeaseId: string | null;
        toolApprovalGrant: string | null;
        toolIdempotencyKey: string | null;
        toolResultJson: string | null;
        toolDeadline: string | null;
        toolInvocation: {
            __typename?: 'AgentToolInvocation';
            protocolVersion: string;
            sessionId: string;
            runId: string;
            toolCallId: string;
            name: string;
            version: string;
            descriptorDigest: string;
            argumentsJson: string;
            argumentHash: string;
            contextVersion: string;
            clientEpoch: string | null;
            leaseId: string | null;
            approvalGrant: string | null;
            idempotencyKey: string | null;
            deadline: string;
        } | null;
        toolResult: {
            __typename?: 'AgentToolResultEnvelope';
            protocolVersion: string;
            toolCallId: string;
            status: CrowdyStudioAgentToolResultStatus;
            outputJson: string | null;
            observedContextVersion: string;
            startedAt: string;
            finishedAt: string;
            error: {
                __typename?: 'AgentError';
                code: string;
                message: string;
                retryable: boolean;
                remediation: string | null;
                field: string | null;
                requiredScope: string | null;
            } | null;
        } | null;
        toolError: {
            __typename?: 'AgentError';
            code: string;
            message: string;
            retryable: boolean;
            remediation: string | null;
            field: string | null;
            requiredScope: string | null;
        } | null;
    };
};
export type GridOwnershipFieldsFragment = {
    __typename?: 'GridOwnership';
    gridOwnershipId: string;
    gridId: string;
    appId: string;
    ownerKind: GridOwnerKind;
    ownerRef: string;
    tenure: GridTenure;
    acquiredVia: string;
    acquiredAt: string;
    expiresAt: string | null;
};
export type GridOwnershipQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type GridOwnershipQuery = {
    __typename?: 'Query';
    gridOwnership: {
        __typename?: 'GridOwnership';
        gridOwnershipId: string;
        gridId: string;
        appId: string;
        ownerKind: GridOwnerKind;
        ownerRef: string;
        tenure: GridTenure;
        acquiredVia: string;
        acquiredAt: string;
        expiresAt: string | null;
    } | null;
};
export type AssignGridOwnershipMutationVariables = Exact<{
    input: AssignGridOwnershipInput;
}>;
export type AssignGridOwnershipMutation = {
    __typename?: 'Mutation';
    assignGridOwnership: {
        __typename?: 'GridOwnership';
        gridOwnershipId: string;
        gridId: string;
        appId: string;
        ownerKind: GridOwnerKind;
        ownerRef: string;
        tenure: GridTenure;
        acquiredVia: string;
        acquiredAt: string;
        expiresAt: string | null;
    };
};
export type TransferGridOwnershipMutationVariables = Exact<{
    input: TransferGridOwnershipInput;
}>;
export type TransferGridOwnershipMutation = {
    __typename?: 'Mutation';
    transferGridOwnership: {
        __typename?: 'GridOwnership';
        gridOwnershipId: string;
        gridId: string;
        appId: string;
        ownerKind: GridOwnerKind;
        ownerRef: string;
        tenure: GridTenure;
        acquiredVia: string;
        acquiredAt: string;
        expiresAt: string | null;
    };
};
export type GridUserPermissionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type GridUserPermissionsQuery = {
    __typename?: 'Query';
    gridUserPermissions: {
        __typename?: 'GridUserPermissions';
        appId: string;
        gridId: string;
        userId: string;
        permissionKeys: Array<string>;
    };
};
export type NearbyGridPermissionsQueryVariables = Exact<{
    input: NearbyGridPermissionsInput;
}>;
export type NearbyGridPermissionsQuery = {
    __typename?: 'Query';
    nearbyGridPermissions: Array<{
        __typename?: 'NearbyGridPermissions';
        appId: string;
        gridId: string;
        userId: string;
        permissionKeys: Array<string>;
        lowChunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        highChunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    }>;
};
export type GridPermissionLimitsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type GridPermissionLimitsQuery = {
    __typename?: 'Query';
    gridPermissionLimits: {
        __typename?: 'GridPermissionLimits';
        appId: string;
        gridId: string;
        permissionKeys: Array<string>;
    };
};
export type GridGroupGrantsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    groupId: Scalars['BigInt']['input'];
}>;
export type GridGroupGrantsQuery = {
    __typename?: 'Query';
    gridGroupGrants: Array<{
        __typename?: 'GridGroupGrant';
        appId: string;
        gridId: string;
        groupId: string;
        groupRoleId: string | null;
        permissionKey: string;
        expiresAt: string | null;
    }>;
};
export type CreateGridMutationVariables = Exact<{
    input: CreateGridInput;
}>;
export type CreateGridMutation = {
    __typename?: 'Mutation';
    createGrid: {
        __typename?: 'CreateGridResponse';
        error: UdpErrorCode;
        grid: {
            __typename?: 'Grid';
            grid_id: string;
            app_id: string;
            low_chunk: {
                __typename?: 'ChunkCoordinates';
                x: string;
                y: string;
                z: string;
            };
            high_chunk: {
                __typename?: 'ChunkCoordinates';
                x: string;
                y: string;
                z: string;
            };
        } | null;
    };
};
export type DeleteGridMutationVariables = Exact<{
    input: DeleteGridInput;
}>;
export type DeleteGridMutation = {
    __typename?: 'Mutation';
    deleteGrid: {
        __typename?: 'DeleteGridResponse';
        gridId: string | null;
        error: UdpErrorCode;
    };
};
export type GrantGridPermissionsMutationVariables = Exact<{
    input: GrantGridPermissionsInput;
}>;
export type GrantGridPermissionsMutation = {
    __typename?: 'Mutation';
    grantGridPermissions: {
        __typename?: 'GridUserPermissions';
        appId: string;
        gridId: string;
        userId: string;
        permissionKeys: Array<string>;
    };
};
export type RevokeGridPermissionsMutationVariables = Exact<{
    input: RevokeGridPermissionsInput;
}>;
export type RevokeGridPermissionsMutation = {
    __typename?: 'Mutation';
    revokeGridPermissions: {
        __typename?: 'GridUserPermissions';
        appId: string;
        gridId: string;
        userId: string;
        permissionKeys: Array<string>;
    };
};
export type SetGridPermissionLimitsMutationVariables = Exact<{
    input: SetGridPermissionLimitsInput;
}>;
export type SetGridPermissionLimitsMutation = {
    __typename?: 'Mutation';
    setGridPermissionLimits: {
        __typename?: 'GridPermissionLimits';
        appId: string;
        gridId: string;
        permissionKeys: Array<string>;
    };
};
export type AssignGroupToGridMutationVariables = Exact<{
    input: AssignGroupToGridInput;
}>;
export type AssignGroupToGridMutation = {
    __typename?: 'Mutation';
    assignGroupToGrid: Array<{
        __typename?: 'GridGroupGrant';
        appId: string;
        gridId: string;
        groupId: string;
        groupRoleId: string | null;
        permissionKey: string;
        expiresAt: string | null;
    }>;
};
export type RevokeGroupFromGridMutationVariables = Exact<{
    input: RevokeGroupFromGridInput;
}>;
export type RevokeGroupFromGridMutation = {
    __typename?: 'Mutation';
    revokeGroupFromGrid: Array<{
        __typename?: 'GridGroupGrant';
        appId: string;
        gridId: string;
        groupId: string;
        groupRoleId: string | null;
        permissionKey: string;
        expiresAt: string | null;
    }>;
};
export type GmAutomationFieldsFragment = {
    __typename?: 'GmAutomation';
    automationId: string;
    appId: string;
    name: string;
    description: string | null;
    enabled: boolean;
    actionKind: string;
    functionName: string | null;
    computeModuleName: string | null;
    computeExport: string | null;
    targetMode: string;
    selfContainerId: string | null;
    targetTypeName: string | null;
    sessionId: string | null;
    paramsJson: string;
    selectorJson: string | null;
    runAsUserId: string | null;
    triggerType: string;
    scheduleKind: string | null;
    intervalMs: number | null;
    cronExpr: string | null;
    maxTargets: number;
    maxFnDepth: number | null;
    gasLimit: number | null;
    runTimeoutMs: number | null;
    maxRunsPerMinute: number;
    failureThreshold: number;
    cooldownMs: number;
    circuitState: string;
    consecutiveFailures: number;
    pausedUntil: string | null;
    lastError: string | null;
    lastRunAt: string | null;
    nextRunAt: string | null;
};
export type GmAutomationTriggerFieldsFragment = {
    __typename?: 'GmAutomationTrigger';
    triggerId: string;
    appId: string;
    automationId: string;
    onEvent: string;
    functionName: string | null;
    containerTypeName: string | null;
    propertyKey: string | null;
    writeSource: string;
    debounceMs: number;
    lastMatchedAt: string | null;
    matchCount24h: number;
    warnings: Array<string>;
};
export type GmAutomationPolicyFieldsFragment = {
    __typename?: 'GmAutomationPolicy';
    appId: string;
    enabled: boolean;
    maxAutomations: number;
    minIntervalMs: number;
    maxFanout: number;
    maxCascadeDepth: number;
    globalRunsPerMinute: number;
    minTimerDelayMs: number;
    maxPendingTimers: number;
};
export type GmAutomationRunFieldsFragment = {
    __typename?: 'GmAutomationRun';
    runId: string;
    appId: string;
    flowId: string | null;
    automationId: string | null;
    automationName: string;
    triggerSource: string;
    triggerId: string | null;
    parentRunId: string | null;
    cascadeDepth: number;
    startedAt: string;
    finishedAt: string | null;
    durationUs: number;
    targets: number;
    invocations: number;
    mutations: number;
    fnCalls: number;
    gasUsed: number;
    success: boolean;
    errorMessage: string | null;
    circuitAction: string | null;
    computeUnits: number;
};
export type GameModelUpsertAutomationMutationVariables = Exact<{
    input: UpsertAutomationInput;
}>;
export type GameModelUpsertAutomationMutation = {
    __typename?: 'Mutation';
    gameModelUpsertAutomation: {
        __typename?: 'GmAutomation';
        automationId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        actionKind: string;
        functionName: string | null;
        computeModuleName: string | null;
        computeExport: string | null;
        targetMode: string;
        selfContainerId: string | null;
        targetTypeName: string | null;
        sessionId: string | null;
        paramsJson: string;
        selectorJson: string | null;
        runAsUserId: string | null;
        triggerType: string;
        scheduleKind: string | null;
        intervalMs: number | null;
        cronExpr: string | null;
        maxTargets: number;
        maxFnDepth: number | null;
        gasLimit: number | null;
        runTimeoutMs: number | null;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
    };
};
export type GameModelDeleteAutomationMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type GameModelDeleteAutomationMutation = {
    __typename?: 'Mutation';
    gameModelDeleteAutomation: boolean;
};
export type GameModelSetAutomationEnabledMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    enabled: Scalars['Boolean']['input'];
}>;
export type GameModelSetAutomationEnabledMutation = {
    __typename?: 'Mutation';
    gameModelSetAutomationEnabled: {
        __typename?: 'GmAutomation';
        automationId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        actionKind: string;
        functionName: string | null;
        computeModuleName: string | null;
        computeExport: string | null;
        targetMode: string;
        selfContainerId: string | null;
        targetTypeName: string | null;
        sessionId: string | null;
        paramsJson: string;
        selectorJson: string | null;
        runAsUserId: string | null;
        triggerType: string;
        scheduleKind: string | null;
        intervalMs: number | null;
        cronExpr: string | null;
        maxTargets: number;
        maxFnDepth: number | null;
        gasLimit: number | null;
        runTimeoutMs: number | null;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
    };
};
export type GameModelUpsertAutomationTriggerMutationVariables = Exact<{
    input: UpsertAutomationTriggerInput;
}>;
export type GameModelUpsertAutomationTriggerMutation = {
    __typename?: 'Mutation';
    gameModelUpsertAutomationTrigger: {
        __typename?: 'GmAutomationTrigger';
        triggerId: string;
        appId: string;
        automationId: string;
        onEvent: string;
        functionName: string | null;
        containerTypeName: string | null;
        propertyKey: string | null;
        writeSource: string;
        debounceMs: number;
        lastMatchedAt: string | null;
        matchCount24h: number;
        warnings: Array<string>;
    };
};
export type GameModelDeleteAutomationTriggerMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    triggerId: Scalars['String']['input'];
}>;
export type GameModelDeleteAutomationTriggerMutation = {
    __typename?: 'Mutation';
    gameModelDeleteAutomationTrigger: boolean;
};
export type GameModelSetAutomationPolicyMutationVariables = Exact<{
    input: SetAutomationPolicyInput;
}>;
export type GameModelSetAutomationPolicyMutation = {
    __typename?: 'Mutation';
    gameModelSetAutomationPolicy: {
        __typename?: 'GmAutomationPolicy';
        appId: string;
        enabled: boolean;
        maxAutomations: number;
        minIntervalMs: number;
        maxFanout: number;
        maxCascadeDepth: number;
        globalRunsPerMinute: number;
        minTimerDelayMs: number;
        maxPendingTimers: number;
    };
};
export type GameModelRunAutomationMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type GameModelRunAutomationMutation = {
    __typename?: 'Mutation';
    gameModelRunAutomation: {
        __typename?: 'GmAutomationRun';
        runId: string;
        appId: string;
        flowId: string | null;
        automationId: string | null;
        automationName: string;
        triggerSource: string;
        triggerId: string | null;
        parentRunId: string | null;
        cascadeDepth: number;
        startedAt: string;
        finishedAt: string | null;
        durationUs: number;
        targets: number;
        invocations: number;
        mutations: number;
        fnCalls: number;
        gasUsed: number;
        success: boolean;
        errorMessage: string | null;
        circuitAction: string | null;
        computeUnits: number;
    };
};
export type GameModelAutomationsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelAutomationsQuery = {
    __typename?: 'Query';
    gameModelAutomations: Array<{
        __typename?: 'GmAutomation';
        automationId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        actionKind: string;
        functionName: string | null;
        computeModuleName: string | null;
        computeExport: string | null;
        targetMode: string;
        selfContainerId: string | null;
        targetTypeName: string | null;
        sessionId: string | null;
        paramsJson: string;
        selectorJson: string | null;
        runAsUserId: string | null;
        triggerType: string;
        scheduleKind: string | null;
        intervalMs: number | null;
        cronExpr: string | null;
        maxTargets: number;
        maxFnDepth: number | null;
        gasLimit: number | null;
        runTimeoutMs: number | null;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
    }>;
};
export type GameModelAutomationQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type GameModelAutomationQuery = {
    __typename?: 'Query';
    gameModelAutomation: {
        __typename?: 'GmAutomation';
        automationId: string;
        appId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        actionKind: string;
        functionName: string | null;
        computeModuleName: string | null;
        computeExport: string | null;
        targetMode: string;
        selfContainerId: string | null;
        targetTypeName: string | null;
        sessionId: string | null;
        paramsJson: string;
        selectorJson: string | null;
        runAsUserId: string | null;
        triggerType: string;
        scheduleKind: string | null;
        intervalMs: number | null;
        cronExpr: string | null;
        maxTargets: number;
        maxFnDepth: number | null;
        gasLimit: number | null;
        runTimeoutMs: number | null;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
    };
};
export type GameModelAutomationTriggersQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    automationName?: InputMaybe<Scalars['String']['input']>;
}>;
export type GameModelAutomationTriggersQuery = {
    __typename?: 'Query';
    gameModelAutomationTriggers: Array<{
        __typename?: 'GmAutomationTrigger';
        triggerId: string;
        appId: string;
        automationId: string;
        onEvent: string;
        functionName: string | null;
        containerTypeName: string | null;
        propertyKey: string | null;
        writeSource: string;
        debounceMs: number;
        lastMatchedAt: string | null;
        matchCount24h: number;
        warnings: Array<string>;
    }>;
};
export type GameModelAutomationPolicyQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelAutomationPolicyQuery = {
    __typename?: 'Query';
    gameModelAutomationPolicy: {
        __typename?: 'GmAutomationPolicy';
        appId: string;
        enabled: boolean;
        maxAutomations: number;
        minIntervalMs: number;
        maxFanout: number;
        maxCascadeDepth: number;
        globalRunsPerMinute: number;
        minTimerDelayMs: number;
        maxPendingTimers: number;
    };
};
export type GameModelAutomationRunsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    automationName?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type GameModelAutomationRunsQuery = {
    __typename?: 'Query';
    gameModelAutomationRuns: Array<{
        __typename?: 'GmAutomationRun';
        runId: string;
        appId: string;
        flowId: string | null;
        automationId: string | null;
        automationName: string;
        triggerSource: string;
        triggerId: string | null;
        parentRunId: string | null;
        cascadeDepth: number;
        startedAt: string;
        finishedAt: string | null;
        durationUs: number;
        targets: number;
        invocations: number;
        mutations: number;
        fnCalls: number;
        gasUsed: number;
        success: boolean;
        errorMessage: string | null;
        circuitAction: string | null;
        computeUnits: number;
    }>;
};
export type GameModelAutomationStatsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    windowMinutes?: InputMaybe<Scalars['Int']['input']>;
}>;
export type GameModelAutomationStatsQuery = {
    __typename?: 'Query';
    gameModelAutomationStats: {
        __typename?: 'GmAutomationStats';
        windowMinutes: number;
        totalRuns: number;
        failedRuns: number;
        failureRatePct: number;
        runsPerMinute: number;
        totalInvocations: number;
        totalMutations: number;
        totalComputeUnits: number;
        avgDurationUs: number;
        byAutomation: Array<{
            __typename?: 'GmAutomationStat';
            automationName: string;
            runs: number;
            failures: number;
            invocations: number;
            computeUnits: number;
            avgDurationUs: number;
            circuitState: string;
        }>;
    };
};
export type GameModelAppDiagnosticsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelAppDiagnosticsQuery = {
    __typename?: 'Query';
    gameModelAppDiagnostics: {
        __typename?: 'GmAppDiagnostics';
        appId: string;
        containerCount: number;
        propertyCount: number;
        edgeCount: number;
        sessionCount: number;
        functionCount: number;
        automationCount: number;
        eventCount: number;
        events24h: number;
        failedEvents24h: number;
        automationEvents24h: number;
        topFunctions: Array<{
            __typename?: 'GmTopFunction';
            functionName: string;
            invocations: number;
            failures: number;
        }>;
    };
};
export type GmTimerFieldsFragment = {
    __typename?: 'GmTimer';
    timerId: string;
    appId: string;
    sessionId: string | null;
    selfContainerId: string;
    functionName: string;
    paramsJson: string;
    fireAt: string;
    dedupeKey: string | null;
    cascadeDepth: number;
    flowId: string | null;
    armedBy: string;
    createdAt: string;
};
export type GameModelScheduleInvokeMutationVariables = Exact<{
    input: ScheduleInvokeInput;
}>;
export type GameModelScheduleInvokeMutation = {
    __typename?: 'Mutation';
    gameModelScheduleInvoke: {
        __typename?: 'GmTimer';
        timerId: string;
        appId: string;
        sessionId: string | null;
        selfContainerId: string;
        functionName: string;
        paramsJson: string;
        fireAt: string;
        dedupeKey: string | null;
        cascadeDepth: number;
        flowId: string | null;
        armedBy: string;
        createdAt: string;
    };
};
export type GameModelCancelTimerMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    timerId?: InputMaybe<Scalars['String']['input']>;
    dedupeKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type GameModelCancelTimerMutation = {
    __typename?: 'Mutation';
    gameModelCancelTimer: number;
};
export type GameModelTimersQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    sessionId?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type GameModelTimersQuery = {
    __typename?: 'Query';
    gameModelTimers: Array<{
        __typename?: 'GmTimer';
        timerId: string;
        appId: string;
        sessionId: string | null;
        selfContainerId: string;
        functionName: string;
        paramsJson: string;
        fireAt: string;
        dedupeKey: string | null;
        cascadeDepth: number;
        flowId: string | null;
        armedBy: string;
        createdAt: string;
    }>;
};
export type GameModelActivePlayerCountQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelActivePlayerCountQuery = {
    __typename?: 'Query';
    gameModelActivePlayerCount: {
        __typename?: 'GameModelActivePlayerCountSnapshot';
        appId: string;
        activePlayerCount: number;
        status: GameModelPlayerCountStatus;
        observedAt: string | null;
        revision: string;
    };
};
export type GameModelActivePlayerCountChangedSubscriptionVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelActivePlayerCountChangedSubscription = {
    __typename?: 'Subscription';
    gameModelActivePlayerCountChanged: {
        __typename?: 'GameModelActivePlayerCountChange';
        appId: string;
        previousCount: number;
        currentCount: number;
        delta: number;
        revision: string;
        observedAt: string;
    };
};
export type GmSessionFieldsFragment = {
    __typename?: 'GmSession';
    sessionId: string;
    appId: string;
    name: string | null;
    status: string;
    createdByUserId: string | null;
    currentTurnUserId: string | null;
    metadataJson: string;
};
export type GmContainerFieldsFragment = {
    __typename?: 'GmContainer';
    containerId: string;
    appId: string;
    sessionId: string | null;
    typeName: string;
    displayName: string;
    description: string | null;
    ownerUserId: string | null;
    metadataJson: string;
};
export type GmInvokeResultFieldsFragment = {
    __typename?: 'GmInvokeResult';
    eventId: string;
    functionName: string;
    success: boolean;
    returnValueJson: string | null;
    errorMessage: string | null;
    fault: {
        __typename?: 'PlayerFaultInfo';
        code: PlayerFaultCode;
        blame: UserCodeFaultBlame;
        retryable: boolean;
    } | null;
    mutationsApplied: Array<{
        __typename?: 'GmMutationApplied';
        containerId: string;
        key: string;
        valueType: string;
        oldValueJson: string | null;
        newValueJson: string | null;
    }>;
};
export type GameModelCreateSessionMutationVariables = Exact<{
    input: CreateSessionInput;
}>;
export type GameModelCreateSessionMutation = {
    __typename?: 'Mutation';
    gameModelCreateSession: {
        __typename?: 'GmSession';
        sessionId: string;
        appId: string;
        name: string | null;
        status: string;
        createdByUserId: string | null;
        currentTurnUserId: string | null;
        metadataJson: string;
    };
};
export type GameModelJoinSessionMutationVariables = Exact<{
    input: JoinSessionInput;
}>;
export type GameModelJoinSessionMutation = {
    __typename?: 'Mutation';
    gameModelJoinSession: {
        __typename?: 'GmSessionParticipant';
        sessionId: string;
        userId: string;
        role: string;
    };
};
export type GameModelSetSessionTurnMutationVariables = Exact<{
    input: SetSessionTurnInput;
}>;
export type GameModelSetSessionTurnMutation = {
    __typename?: 'Mutation';
    gameModelSetSessionTurn: {
        __typename?: 'GmSession';
        sessionId: string;
        appId: string;
        name: string | null;
        status: string;
        createdByUserId: string | null;
        currentTurnUserId: string | null;
        metadataJson: string;
    };
};
export type GameModelCreateContainerMutationVariables = Exact<{
    input: CreateContainerInput;
}>;
export type GameModelCreateContainerMutation = {
    __typename?: 'Mutation';
    gameModelCreateContainer: {
        __typename?: 'GmContainer';
        containerId: string;
        appId: string;
        sessionId: string | null;
        typeName: string;
        displayName: string;
        description: string | null;
        ownerUserId: string | null;
        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;
}>;
export type GameModelSetPropertyMutation = {
    __typename?: 'Mutation';
    gameModelSetProperty: {
        __typename?: 'GmContainer';
        containerId: string;
        appId: string;
        sessionId: string | null;
        typeName: string;
        displayName: string;
        description: string | null;
        ownerUserId: string | null;
        metadataJson: string;
    };
};
export type GameModelAddEdgeMutationVariables = Exact<{
    input: AddEdgeInput;
}>;
export type GameModelAddEdgeMutation = {
    __typename?: 'Mutation';
    gameModelAddEdge: {
        __typename?: 'GmEdge';
        edgeId: string;
        fromContainerId: string;
        toContainerId: string;
        relationshipType: string;
        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;
}>;
export type GameModelInvokeMutation = {
    __typename?: 'Mutation';
    gameModelInvoke: {
        __typename?: 'GmInvokeResult';
        eventId: string;
        functionName: string;
        success: boolean;
        returnValueJson: string | null;
        errorMessage: string | null;
        fault: {
            __typename?: 'PlayerFaultInfo';
            code: PlayerFaultCode;
            blame: UserCodeFaultBlame;
            retryable: boolean;
        } | null;
        mutationsApplied: Array<{
            __typename?: 'GmMutationApplied';
            containerId: string;
            key: string;
            valueType: string;
            oldValueJson: string | null;
            newValueJson: string | null;
        }>;
    };
};
export type GameModelContainerQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    containerId: Scalars['String']['input'];
}>;
export type GameModelContainerQuery = {
    __typename?: 'Query';
    gameModelContainer: {
        __typename?: 'GmContainer';
        containerId: string;
        appId: string;
        sessionId: string | null;
        typeName: string;
        displayName: string;
        description: string | null;
        ownerUserId: string | null;
        metadataJson: string;
    };
};
export type GameModelContainersQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    typeName?: InputMaybe<Scalars['String']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
    where?: InputMaybe<Array<GmPropertyPredicateInput> | GmPropertyPredicateInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type GameModelContainersQuery = {
    __typename?: 'Query';
    gameModelContainers: Array<{
        __typename?: 'GmContainer';
        containerId: string;
        appId: string;
        sessionId: string | null;
        typeName: string;
        displayName: string;
        description: string | null;
        ownerUserId: string | null;
        metadataJson: string;
    }>;
};
export type GameModelContainerChangedSubscriptionVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    typeName?: InputMaybe<Scalars['String']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
}>;
export type GameModelContainerChangedSubscription = {
    __typename?: 'Subscription';
    gameModelContainerChanged: {
        __typename?: 'GmContainerChange';
        appId: string;
        containerId: string;
        typeName: string | null;
        sessionId: string | null;
        source: string;
        functionName: string | null;
        changedKeys: Array<string>;
        occurredAt: string;
    };
};
export type GameModelContainerStateQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    containerId: Scalars['String']['input'];
}>;
export type GameModelContainerStateQuery = {
    __typename?: 'Query';
    gameModelContainerState: {
        __typename?: 'GmContainerState';
        containerId: string;
        appId: string;
        sessionId: string | null;
        typeName: string;
        displayName: string;
        ownerUserId: string | null;
        propertiesJson: string;
    };
};
export type GameModelTraverseQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    rootId: Scalars['String']['input'];
    relationshipType: Scalars['String']['input'];
    depth?: InputMaybe<Scalars['Int']['input']>;
}>;
export type GameModelTraverseQuery = {
    __typename?: 'Query';
    gameModelTraverse: {
        __typename?: 'GmTraverseResult';
        rootId: string;
        nodes: Array<{
            __typename?: 'GmContainer';
            containerId: string;
            appId: string;
            sessionId: string | null;
            typeName: string;
            displayName: string;
            description: string | null;
            ownerUserId: string | null;
            metadataJson: string;
        }>;
        edges: Array<{
            __typename?: 'GmEdge';
            edgeId: string;
            fromContainerId: string;
            toContainerId: string;
            relationshipType: string;
            weight: number | null;
        }>;
    };
};
export type GameModelSessionQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    sessionId: Scalars['String']['input'];
}>;
export type GameModelSessionQuery = {
    __typename?: 'Query';
    gameModelSession: {
        __typename?: 'GmSession';
        sessionId: string;
        appId: string;
        name: string | null;
        status: string;
        createdByUserId: string | null;
        currentTurnUserId: string | null;
        metadataJson: string;
    };
};
export type GameModelSessionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    status?: InputMaybe<Scalars['String']['input']>;
}>;
export type GameModelSessionsQuery = {
    __typename?: 'Query';
    gameModelSessions: Array<{
        __typename?: 'GmSession';
        sessionId: string;
        appId: string;
        name: string | null;
        status: string;
        createdByUserId: string | null;
        currentTurnUserId: string | null;
        metadataJson: string;
    }>;
};
export type GameModelEventsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    sessionId?: InputMaybe<Scalars['String']['input']>;
    selfContainerId?: InputMaybe<Scalars['String']['input']>;
    functionName?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type GameModelEventsQuery = {
    __typename?: 'Query';
    gameModelEvents: Array<{
        __typename?: 'GmEvent';
        eventId: string;
        flowId: string | null;
        sessionId: string | null;
        functionName: string;
        selfContainerId: string | null;
        callerUserId: string | null;
        callerKind: string;
        automationId: string | null;
        paramsJson: string;
        mutationsAppliedJson: string;
        permissionEffectsAppliedJson: string;
        returnValueJson: string | null;
        success: boolean;
        errorMessage: string | null;
        executedAt: string;
    }>;
};
export type GameModelEventsConnectionQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
    sessionId?: InputMaybe<Scalars['String']['input']>;
    selfContainerId?: InputMaybe<Scalars['String']['input']>;
    functionName?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
}>;
export type GameModelEventsConnectionQuery = {
    __typename?: 'Query';
    gameModelEventsConnection: {
        __typename?: 'GameModelEventsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'GmEventEdge';
            cursor: string;
            node: {
                __typename?: 'GmEvent';
                eventId: string;
                flowId: string | null;
                sessionId: string | null;
                functionName: string;
                selfContainerId: string | null;
                callerUserId: string | null;
                callerKind: string;
                automationId: string | null;
                paramsJson: string;
                mutationsAppliedJson: string;
                permissionEffectsAppliedJson: string;
                returnValueJson: string | null;
                success: boolean;
                errorMessage: string | null;
                executedAt: string;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type GameModelFlowQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    flowId: Scalars['String']['input'];
}>;
export type GameModelFlowQuery = {
    __typename?: 'Query';
    gameModelFlow: {
        __typename?: 'GmFlowTimeline';
        flowId: string;
        events: Array<{
            __typename?: 'GmEvent';
            eventId: string;
            flowId: string | null;
            sessionId: string | null;
            functionName: string;
            selfContainerId: string | null;
            callerUserId: string | null;
            callerKind: string;
            automationId: string | null;
            paramsJson: string;
            mutationsAppliedJson: string;
            permissionEffectsAppliedJson: string;
            returnValueJson: string | null;
            success: boolean;
            errorMessage: string | null;
            executedAt: string;
        }>;
        automationRuns: Array<{
            __typename?: 'GmAutomationRun';
            runId: string;
            appId: string;
            flowId: string | null;
            automationId: string | null;
            automationName: string;
            triggerSource: string;
            triggerId: string | null;
            parentRunId: string | null;
            cascadeDepth: number;
            startedAt: string;
            finishedAt: string | null;
            durationUs: number;
            targets: number;
            invocations: number;
            mutations: number;
            fnCalls: number;
            gasUsed: number;
            success: boolean;
            errorMessage: string | null;
            circuitAction: string | null;
            computeUnits: number;
        }>;
        moduleRuns: Array<{
            __typename?: 'WasmModuleRun';
            runId: string;
            appId: string;
            flowId: string | null;
            moduleId: string;
            moduleName: string;
            triggerSource: string;
            entry: string | null;
            startedAt: string;
            durationUs: number;
            fuelUsed: string;
            dbReads: number;
            dbWrites: number;
            egressMsgs: number;
            egressBytes: string;
            success: boolean;
            errorMessage: string | null;
            circuitAction: string | null;
        }>;
    };
};
export type GmFunctionFieldsFragment = {
    __typename?: 'GmFunction';
    functionId: string;
    appId: string;
    name: string;
    containerTypeName: string | null;
    description: string | null;
    returnType: string | null;
    invokeScope: string;
    invokePolicyJson: string | null;
    autonomousInvocable: boolean;
    returnExpression: string | null;
    warnings: Array<string>;
    parameters: Array<{
        __typename?: 'GmFunctionParam';
        name: string;
        valueType: string;
        required: boolean;
        defaultValueJson: string | null;
        description: string | null;
        sortOrder: number;
    }>;
    mutations: Array<{
        __typename?: 'GmFunctionMutation';
        target: string;
        property: string;
        expression: string;
    }>;
    notifications: Array<{
        __typename?: 'GmFunctionNotification';
        kind: string;
        emitAs: string | null;
        args: Array<{
            __typename?: 'GmNotificationArg';
            name: string;
            expression: string;
        }>;
    }>;
    permissionEffects: Array<{
        __typename?: 'GmFunctionPermissionEffect';
        action: string;
        permissionKeys: Array<string>;
        userExpression: string;
        gridIdExpression: string;
        ttlSecondsExpression: string | null;
    }>;
    timers: Array<{
        __typename?: 'GmFunctionTimer';
        functionName: string;
        target: string;
        delayMsExpression: string;
        dedupeKeyExpression: string | null;
        params: Array<{
            __typename?: 'GmTimerParam';
            name: string;
            expression: string;
        }>;
    }>;
};
export type GmPropertyDefFieldsFragment = {
    __typename?: 'GmPropertyDef';
    appId: string;
    containerTypeName: string;
    key: string;
    valueType: string;
    defaultValueJson: string | null;
    visibility: string;
    writable: string;
    description: string | null;
};
export type GameModelSeedMutationVariables = Exact<{
    input: SeedGameModelInput;
}>;
export type GameModelSeedMutation = {
    __typename?: 'Mutation';
    gameModelSeed: {
        __typename?: 'GmSeedResult';
        containerTypesCreated: number;
        propertyDefinitionsCreated: number;
        functionsCreated: number;
        containersCreated: number;
        edgesCreated: number;
        warnings: Array<string>;
        idMapJson: string;
    };
};
export type GameModelUpsertContainerTypeMutationVariables = Exact<{
    input: UpsertContainerTypeInput;
}>;
export type GameModelUpsertContainerTypeMutation = {
    __typename?: 'Mutation';
    gameModelUpsertContainerType: {
        __typename?: 'GmContainerType';
        appId: string;
        typeName: string;
        displayName: string;
        description: string | null;
        instantiableBy: string;
        defaultPropertyVisibility: string;
        metadataJson: string;
    };
};
export type GameModelUpsertPropertyDefMutationVariables = Exact<{
    input: UpsertPropertyDefInput;
}>;
export type GameModelUpsertPropertyDefMutation = {
    __typename?: 'Mutation';
    gameModelUpsertPropertyDef: {
        __typename?: 'GmPropertyDef';
        appId: string;
        containerTypeName: string;
        key: string;
        valueType: string;
        defaultValueJson: string | null;
        visibility: string;
        writable: string;
        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;
}>;
export type GameModelUpsertFunctionMutation = {
    __typename?: 'Mutation';
    gameModelUpsertFunction: {
        __typename?: 'GmFunction';
        functionId: string;
        appId: string;
        name: string;
        containerTypeName: string | null;
        description: string | null;
        returnType: string | null;
        invokeScope: string;
        invokePolicyJson: string | null;
        autonomousInvocable: boolean;
        returnExpression: string | null;
        warnings: Array<string>;
        parameters: Array<{
            __typename?: 'GmFunctionParam';
            name: string;
            valueType: string;
            required: boolean;
            defaultValueJson: string | null;
            description: string | null;
            sortOrder: number;
        }>;
        mutations: Array<{
            __typename?: 'GmFunctionMutation';
            target: string;
            property: string;
            expression: string;
        }>;
        notifications: Array<{
            __typename?: 'GmFunctionNotification';
            kind: string;
            emitAs: string | null;
            args: Array<{
                __typename?: 'GmNotificationArg';
                name: string;
                expression: string;
            }>;
        }>;
        permissionEffects: Array<{
            __typename?: 'GmFunctionPermissionEffect';
            action: string;
            permissionKeys: Array<string>;
            userExpression: string;
            gridIdExpression: string;
            ttlSecondsExpression: string | null;
        }>;
        timers: Array<{
            __typename?: 'GmFunctionTimer';
            functionName: string;
            target: string;
            delayMsExpression: string;
            dedupeKeyExpression: string | null;
            params: Array<{
                __typename?: 'GmTimerParam';
                name: string;
                expression: string;
            }>;
        }>;
    };
};
export type GameModelDeleteFunctionMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type GameModelDeleteFunctionMutation = {
    __typename?: 'Mutation';
    gameModelDeleteFunction: boolean;
};
export type GameModelDefineFeatureMutationVariables = Exact<{
    input: DefineAppFeatureInput;
}>;
export type GameModelDefineFeatureMutation = {
    __typename?: 'Mutation';
    gameModelDefineFeature: {
        __typename?: 'GmAppFeature';
        appId: string;
        featureKey: string;
        description: string | null;
    };
};
export type GameModelGrantTierFeatureMutationVariables = Exact<{
    input: GrantTierFeatureInput;
}>;
export type GameModelGrantTierFeatureMutation = {
    __typename?: 'Mutation';
    gameModelGrantTierFeature: {
        __typename?: 'GmTierFeature';
        appId: string;
        tierId: string;
        featureKey: string;
    };
};
export type GameModelSetPolicyMutationVariables = Exact<{
    input: SetGameModelPolicyInput;
}>;
export type GameModelSetPolicyMutation = {
    __typename?: 'Mutation';
    gameModelSetPolicy: {
        __typename?: 'GmAppPolicy';
        appId: string;
        sessionCreationPolicy: string;
        defaultParticipantRole: string;
    };
};
export type GameModelTypeSchemaQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    typeName: Scalars['String']['input'];
}>;
export type GameModelTypeSchemaQuery = {
    __typename?: 'Query';
    gameModelTypeSchema: {
        __typename?: 'GmTypeSchema';
        typeName: string;
        propertyDefinitions: Array<{
            __typename?: 'GmPropertyDef';
            appId: string;
            containerTypeName: string;
            key: string;
            valueType: string;
            defaultValueJson: string | null;
            visibility: string;
            writable: string;
            description: string | null;
        }>;
        functions: Array<{
            __typename?: 'GmFunction';
            functionId: string;
            appId: string;
            name: string;
            containerTypeName: string | null;
            description: string | null;
            returnType: string | null;
            invokeScope: string;
            invokePolicyJson: string | null;
            autonomousInvocable: boolean;
            returnExpression: string | null;
            warnings: Array<string>;
            parameters: Array<{
                __typename?: 'GmFunctionParam';
                name: string;
                valueType: string;
                required: boolean;
                defaultValueJson: string | null;
                description: string | null;
                sortOrder: number;
            }>;
            mutations: Array<{
                __typename?: 'GmFunctionMutation';
                target: string;
                property: string;
                expression: string;
            }>;
            notifications: Array<{
                __typename?: 'GmFunctionNotification';
                kind: string;
                emitAs: string | null;
                args: Array<{
                    __typename?: 'GmNotificationArg';
                    name: string;
                    expression: string;
                }>;
            }>;
            permissionEffects: Array<{
                __typename?: 'GmFunctionPermissionEffect';
                action: string;
                permissionKeys: Array<string>;
                userExpression: string;
                gridIdExpression: string;
                ttlSecondsExpression: string | null;
            }>;
            timers: Array<{
                __typename?: 'GmFunctionTimer';
                functionName: string;
                target: string;
                delayMsExpression: string;
                dedupeKeyExpression: string | null;
                params: Array<{
                    __typename?: 'GmTimerParam';
                    name: string;
                    expression: string;
                }>;
            }>;
        }>;
    };
};
export type GameModelContainerTypesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelContainerTypesQuery = {
    __typename?: 'Query';
    gameModelContainerTypes: Array<{
        __typename?: 'GmContainerType';
        appId: string;
        typeName: string;
        displayName: string;
        description: string | null;
        instantiableBy: string;
        defaultPropertyVisibility: string;
        metadataJson: string;
    }>;
};
export type GameModelPropertyDefsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    typeName: Scalars['String']['input'];
}>;
export type GameModelPropertyDefsQuery = {
    __typename?: 'Query';
    gameModelPropertyDefs: Array<{
        __typename?: 'GmPropertyDef';
        appId: string;
        containerTypeName: string;
        key: string;
        valueType: string;
        defaultValueJson: string | null;
        visibility: string;
        writable: string;
        description: string | null;
    }>;
};
export type GameModelFunctionQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type GameModelFunctionQuery = {
    __typename?: 'Query';
    gameModelFunction: {
        __typename?: 'GmFunction';
        functionId: string;
        appId: string;
        name: string;
        containerTypeName: string | null;
        description: string | null;
        returnType: string | null;
        invokeScope: string;
        invokePolicyJson: string | null;
        autonomousInvocable: boolean;
        returnExpression: string | null;
        warnings: Array<string>;
        parameters: Array<{
            __typename?: 'GmFunctionParam';
            name: string;
            valueType: string;
            required: boolean;
            defaultValueJson: string | null;
            description: string | null;
            sortOrder: number;
        }>;
        mutations: Array<{
            __typename?: 'GmFunctionMutation';
            target: string;
            property: string;
            expression: string;
        }>;
        notifications: Array<{
            __typename?: 'GmFunctionNotification';
            kind: string;
            emitAs: string | null;
            args: Array<{
                __typename?: 'GmNotificationArg';
                name: string;
                expression: string;
            }>;
        }>;
        permissionEffects: Array<{
            __typename?: 'GmFunctionPermissionEffect';
            action: string;
            permissionKeys: Array<string>;
            userExpression: string;
            gridIdExpression: string;
            ttlSecondsExpression: string | null;
        }>;
        timers: Array<{
            __typename?: 'GmFunctionTimer';
            functionName: string;
            target: string;
            delayMsExpression: string;
            dedupeKeyExpression: string | null;
            params: Array<{
                __typename?: 'GmTimerParam';
                name: string;
                expression: string;
            }>;
        }>;
    };
};
export type GameModelFunctionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    containerTypeName?: InputMaybe<Scalars['String']['input']>;
}>;
export type GameModelFunctionsQuery = {
    __typename?: 'Query';
    gameModelFunctions: Array<{
        __typename?: 'GmFunction';
        functionId: string;
        appId: string;
        name: string;
        containerTypeName: string | null;
        description: string | null;
        returnType: string | null;
        invokeScope: string;
        invokePolicyJson: string | null;
        autonomousInvocable: boolean;
        returnExpression: string | null;
        warnings: Array<string>;
        parameters: Array<{
            __typename?: 'GmFunctionParam';
            name: string;
            valueType: string;
            required: boolean;
            defaultValueJson: string | null;
            description: string | null;
            sortOrder: number;
        }>;
        mutations: Array<{
            __typename?: 'GmFunctionMutation';
            target: string;
            property: string;
            expression: string;
        }>;
        notifications: Array<{
            __typename?: 'GmFunctionNotification';
            kind: string;
            emitAs: string | null;
            args: Array<{
                __typename?: 'GmNotificationArg';
                name: string;
                expression: string;
            }>;
        }>;
        permissionEffects: Array<{
            __typename?: 'GmFunctionPermissionEffect';
            action: string;
            permissionKeys: Array<string>;
            userExpression: string;
            gridIdExpression: string;
            ttlSecondsExpression: string | null;
        }>;
        timers: Array<{
            __typename?: 'GmFunctionTimer';
            functionName: string;
            target: string;
            delayMsExpression: string;
            dedupeKeyExpression: string | null;
            params: Array<{
                __typename?: 'GmTimerParam';
                name: string;
                expression: string;
            }>;
        }>;
    }>;
};
export type GameModelFeaturesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelFeaturesQuery = {
    __typename?: 'Query';
    gameModelFeatures: Array<{
        __typename?: 'GmAppFeature';
        appId: string;
        featureKey: string;
        description: string | null;
    }>;
};
export type GameModelTierFeaturesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
}>;
export type GameModelTierFeaturesQuery = {
    __typename?: 'Query';
    gameModelTierFeatures: Array<{
        __typename?: 'GmTierFeature';
        appId: string;
        tierId: string;
        featureKey: string;
    }>;
};
export type GameModelPolicyQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameModelPolicyQuery = {
    __typename?: 'Query';
    gameModelPolicy: {
        __typename?: 'GmAppPolicy';
        appId: string;
        sessionCreationPolicy: string;
        defaultParticipantRole: string;
    };
};
export type GameModelRevokeTierFeatureMutationVariables = Exact<{
    input: GrantTierFeatureInput;
}>;
export type GameModelRevokeTierFeatureMutation = {
    __typename?: 'Mutation';
    gameModelRevokeTierFeature: boolean;
};
export type GameHostQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameHostQuery = {
    __typename?: 'Query';
    gameHost: {
        __typename?: 'GameHost';
        hostUserId: string;
        actorCount: number;
        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'];
}>;
export type ActorHeartbeatMutation = {
    __typename?: 'Mutation';
    actorHeartbeat: {
        __typename?: 'GameHost';
        hostUserId: string;
        actorCount: number;
        earliestActorJoinedAt: string;
    } | null;
};
export type PlayerCodeListingFieldsFragment = {
    __typename?: 'PlayerCodeListing';
    listingId: string;
    appId: string;
    ownerKind: PlayerCodeOwnerKind;
    ownerRef: string;
    name: string;
    description: string;
    mediaJson: string;
    licenseMode: PlayerCodeLicenseMode;
    acquisitionMode: PlayerCodeAcquisitionMode;
    priceCents: number | null;
    rentIntervalDays: number | null;
    windowDays: number | null;
    unitBudget: string | null;
    status: PlayerCodeListingStatus;
    createdAt: string;
};
export type PlayerCodeListingVersionFieldsFragment = {
    __typename?: 'PlayerCodeListingVersion';
    versionId: string;
    listingId: string;
    versionNo: number;
    serverArtifactHashes: Array<string>;
    clientArtifactHashes: Array<string>;
    capabilitySummaryJson: string;
    capabilityHash: string;
    openSource: boolean;
    licenseText: string | null;
    createdAt: string | null;
    requirements: Array<{
        __typename?: 'PlayerCodeRequirement';
        serverArtifactHash: string;
        clientArtifactHash: string;
    }>;
};
export type PlayerCodeAcquisitionFieldsFragment = {
    __typename?: 'PlayerCodeAcquisition';
    acquisitionId: string;
    listingId: string;
    appId: string;
    mode: PlayerCodeAcquisitionMode;
    status: string;
    expiresAt: string | null;
    unitBudget: string | null;
    unitsConsumed: string;
    acquiredAt: string;
};
export type PlayerCodeInstallFieldsFragment = {
    __typename?: 'PlayerCodeInstall';
    installId: string;
    acquisitionId: string;
    listingId: string;
    appId: string;
    pinnedVersionId: string;
    targetGridId: string | null;
    consentedCapabilityHash: string;
    status: string;
    createdAt: string;
};
export type GridClaimRequestFieldsFragment = {
    __typename?: 'GridClaimRequest';
    requestId: string;
    appId: string;
    gridId: string;
    requesterUserId: string;
    status: string;
    createdAt: string;
};
export type MarketplaceListingsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceListingsQuery = {
    __typename?: 'Query';
    playerCodeListings: Array<{
        __typename?: 'PlayerCodeListing';
        admissionState: PlayerCodeAdmissionState | null;
        latestVersionId: string | null;
        listingId: string;
        appId: string;
        ownerKind: PlayerCodeOwnerKind;
        ownerRef: string;
        name: string;
        description: string;
        mediaJson: string;
        licenseMode: PlayerCodeLicenseMode;
        acquisitionMode: PlayerCodeAcquisitionMode;
        priceCents: number | null;
        rentIntervalDays: number | null;
        windowDays: number | null;
        unitBudget: string | null;
        status: PlayerCodeListingStatus;
        createdAt: string;
    }>;
};
export type MarketplaceListingVersionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
}>;
export type MarketplaceListingVersionsQuery = {
    __typename?: 'Query';
    playerCodeListingVersions: Array<{
        __typename?: 'PlayerCodeListingVersion';
        versionId: string;
        listingId: string;
        versionNo: number;
        serverArtifactHashes: Array<string>;
        clientArtifactHashes: Array<string>;
        capabilitySummaryJson: string;
        capabilityHash: string;
        openSource: boolean;
        licenseText: string | null;
        createdAt: string | null;
        requirements: Array<{
            __typename?: 'PlayerCodeRequirement';
            serverArtifactHash: string;
            clientArtifactHash: string;
        }>;
    }>;
};
export type MarketplaceMyAcquisitionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceMyAcquisitionsQuery = {
    __typename?: 'Query';
    myPlayerCodeAcquisitions: Array<{
        __typename?: 'PlayerCodeAcquisition';
        acquisitionId: string;
        listingId: string;
        appId: string;
        mode: PlayerCodeAcquisitionMode;
        status: string;
        expiresAt: string | null;
        unitBudget: string | null;
        unitsConsumed: string;
        acquiredAt: string;
    }>;
};
export type MarketplaceMyInstallsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceMyInstallsQuery = {
    __typename?: 'Query';
    myPlayerCodeInstalls: Array<{
        __typename?: 'PlayerCodeInstall';
        installId: string;
        acquisitionId: string;
        listingId: string;
        appId: string;
        pinnedVersionId: string;
        targetGridId: string | null;
        consentedCapabilityHash: string;
        status: string;
        createdAt: string;
    }>;
};
export type MarketplaceGridClientModsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type MarketplaceGridClientModsQuery = {
    __typename?: 'Query';
    gridClientMods: Array<{
        __typename?: 'GridClientMod';
        attachmentId: string;
        listingId: string | null;
        listingName: string;
        versionId: string | null;
        sourceKind: string;
        authorKind: PlayerCodeOwnerKind;
        authorRef: string;
        serverVersionId: string | null;
        clientVersionId: string | null;
        clientArtifactHash: string;
        gridId: string;
        capabilitySummaryJson: string;
        capabilityHash: string;
        authorCapabilitySummaryJson: string;
        authorCapabilityHash: string;
        callerConsented: boolean;
        callerTrustsAuthor: boolean;
    }>;
};
export type MarketplaceClientArtifactQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    listingId?: InputMaybe<Scalars['String']['input']>;
    attachmentId?: InputMaybe<Scalars['String']['input']>;
    versionId?: InputMaybe<Scalars['String']['input']>;
}>;
export type MarketplaceClientArtifactQuery = {
    __typename?: 'Query';
    playerCodeClientArtifact: {
        __typename?: 'PlayerClientArtifact';
        versionId: string;
        artifactHash: string;
        artifactBase64: string;
        sizeBytes: number;
        abiVersion: number;
        contractJson: string | null;
        clientFuelPerDispatch: string;
    };
};
export type MarketplaceTrustGridAuthorMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    authorKind: PlayerCodeOwnerKind;
    authorRef: Scalars['BigInt']['input'];
    consentCapabilityHash: Scalars['String']['input'];
}>;
export type MarketplaceTrustGridAuthorMutation = {
    __typename?: 'Mutation';
    trustGridAuthor: boolean;
};
export type MarketplacePublishListingMutationVariables = Exact<{
    input: PublishPlayerCodeInput;
}>;
export type MarketplacePublishListingMutation = {
    __typename?: 'Mutation';
    publishPlayerCode: {
        __typename?: 'PlayerCodeListing';
        admissionState: PlayerCodeAdmissionState | null;
        latestVersionId: string | null;
        listingId: string;
        appId: string;
        ownerKind: PlayerCodeOwnerKind;
        ownerRef: string;
        name: string;
        description: string;
        mediaJson: string;
        licenseMode: PlayerCodeLicenseMode;
        acquisitionMode: PlayerCodeAcquisitionMode;
        priceCents: number | null;
        rentIntervalDays: number | null;
        windowDays: number | null;
        unitBudget: string | null;
        status: PlayerCodeListingStatus;
        createdAt: string;
    };
};
export type MarketplacePublishVersionMutationVariables = Exact<{
    input: PublishPlayerCodeVersionInput;
}>;
export type MarketplacePublishVersionMutation = {
    __typename?: 'Mutation';
    publishPlayerCodeVersion: {
        __typename?: 'PlayerCodeListingVersion';
        versionId: string;
        listingId: string;
        versionNo: number;
        serverArtifactHashes: Array<string>;
        clientArtifactHashes: Array<string>;
        capabilitySummaryJson: string;
        capabilityHash: string;
        openSource: boolean;
        licenseText: string | null;
        createdAt: string | null;
        requirements: Array<{
            __typename?: 'PlayerCodeRequirement';
            serverArtifactHash: string;
            clientArtifactHash: string;
        }>;
    };
};
export type MarketplaceAcquireMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
}>;
export type MarketplaceAcquireMutation = {
    __typename?: 'Mutation';
    acquirePlayerCode: {
        __typename?: 'PlayerCodeAcquisition';
        acquisitionId: string;
        listingId: string;
        appId: string;
        mode: PlayerCodeAcquisitionMode;
        status: string;
        expiresAt: string | null;
        unitBudget: string | null;
        unitsConsumed: string;
        acquiredAt: string;
    };
};
export type MarketplaceInstallMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    acquisitionId: Scalars['String']['input'];
    consentCapabilityHash: Scalars['String']['input'];
    gridId?: InputMaybe<Scalars['BigInt']['input']>;
    versionId?: InputMaybe<Scalars['String']['input']>;
}>;
export type MarketplaceInstallMutation = {
    __typename?: 'Mutation';
    installPlayerCode: {
        __typename?: 'PlayerCodeInstall';
        installId: string;
        acquisitionId: string;
        listingId: string;
        appId: string;
        pinnedVersionId: string;
        targetGridId: string | null;
        consentedCapabilityHash: string;
        status: string;
        createdAt: string;
    };
};
export type MarketplaceUninstallMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    installId: Scalars['String']['input'];
}>;
export type MarketplaceUninstallMutation = {
    __typename?: 'Mutation';
    uninstallPlayerCode: boolean;
};
export type MarketplaceConsentGridClientModMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    attachmentId: Scalars['String']['input'];
    consentCapabilityHash: Scalars['String']['input'];
}>;
export type MarketplaceConsentGridClientModMutation = {
    __typename?: 'Mutation';
    consentGridClientMod: boolean;
};
export type MarketplaceGridClaimPolicyQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceGridClaimPolicyQuery = {
    __typename?: 'Query';
    gridClaimPolicy: GridClaimPolicy;
};
export type MarketplaceGridClaimRequestsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceGridClaimRequestsQuery = {
    __typename?: 'Query';
    gridClaimRequests: Array<{
        __typename?: 'GridClaimRequest';
        requestId: string;
        appId: string;
        gridId: string;
        requesterUserId: string;
        status: string;
        createdAt: string;
    }>;
};
export type MarketplaceClaimGridOwnershipMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type MarketplaceClaimGridOwnershipMutation = {
    __typename?: 'Mutation';
    claimGridOwnership: {
        __typename?: 'GridClaimResult';
        policy: GridClaimPolicy;
        ownershipAssigned: boolean;
        claimRequestId: string | null;
    };
};
export type MarketplaceClaimGridChunkMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    chunk: ChunkCoordinatesInput;
}>;
export type MarketplaceClaimGridChunkMutation = {
    __typename?: 'Mutation';
    claimGridChunk: {
        __typename?: 'ChunkClaimResult';
        gridId: string;
        policy: GridClaimPolicy;
        moddable: boolean;
        effectivePermissionKeys: Array<string>;
        lowChunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        highChunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        ownership: {
            __typename?: 'GridOwnership';
            gridOwnershipId: string;
            ownerKind: GridOwnerKind;
            ownerRef: string;
            tenure: GridTenure;
            acquiredVia: string;
            acquiredAt: string;
            expiresAt: string | null;
        };
    };
};
export type MarketplaceReleaseClaimedGridMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type MarketplaceReleaseClaimedGridMutation = {
    __typename?: 'Mutation';
    releaseClaimedGrid: {
        __typename?: 'ReleaseClaimedGridResult';
        gridId: string;
        policy: GridClaimPolicy;
        released: boolean;
        lowChunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        highChunk: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
    };
};
export type MarketplaceDecideGridClaimMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    requestId: Scalars['String']['input'];
    approve: Scalars['Boolean']['input'];
}>;
export type MarketplaceDecideGridClaimMutation = {
    __typename?: 'Mutation';
    decideGridClaim: {
        __typename?: 'GridClaimRequest';
        requestId: string;
        appId: string;
        gridId: string;
        requesterUserId: string;
        status: string;
        createdAt: string;
    };
};
export type MarketplaceIssueGridClaimInviteMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    inviteeUserId: Scalars['BigInt']['input'];
}>;
export type MarketplaceIssueGridClaimInviteMutation = {
    __typename?: 'Mutation';
    issueGridClaimInvite: boolean;
};
export type MarketplaceAdmissionQueueQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceAdmissionQueueQuery = {
    __typename?: 'Query';
    appCodeAdmissionQueue: Array<{
        __typename?: 'PlayerCodeAdmissionQueueEntry';
        admissionState: PlayerCodeAdmissionState;
        admissionId: string | null;
        matchedSubjectKind: string | null;
        listing: {
            __typename?: 'PlayerCodeListing';
            listingId: string;
            appId: string;
            ownerKind: PlayerCodeOwnerKind;
            ownerRef: string;
            name: string;
            description: string;
            mediaJson: string;
            licenseMode: PlayerCodeLicenseMode;
            acquisitionMode: PlayerCodeAcquisitionMode;
            priceCents: number | null;
            rentIntervalDays: number | null;
            windowDays: number | null;
            unitBudget: string | null;
            status: PlayerCodeListingStatus;
            createdAt: string;
        };
    }>;
};
export type MarketplaceAppListingsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    includeDelisted?: InputMaybe<Scalars['Boolean']['input']>;
}>;
export type MarketplaceAppListingsQuery = {
    __typename?: 'Query';
    appPlayerCodeListings: Array<{
        __typename?: 'PlayerCodeListing';
        updatedAt: string | null;
        listingId: string;
        appId: string;
        ownerKind: PlayerCodeOwnerKind;
        ownerRef: string;
        name: string;
        description: string;
        mediaJson: string;
        licenseMode: PlayerCodeLicenseMode;
        acquisitionMode: PlayerCodeAcquisitionMode;
        priceCents: number | null;
        rentIntervalDays: number | null;
        windowDays: number | null;
        unitBudget: string | null;
        status: PlayerCodeListingStatus;
        createdAt: string;
    }>;
};
export type MarketplaceAppAcquisitionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceAppAcquisitionsQuery = {
    __typename?: 'Query';
    appPlayerCodeAcquisitions: Array<{
        __typename?: 'PlayerCodeAcquisition';
        acquirerUserId: string | null;
        revokedAt: string | null;
        acquisitionId: string;
        listingId: string;
        appId: string;
        mode: PlayerCodeAcquisitionMode;
        status: string;
        expiresAt: string | null;
        unitBudget: string | null;
        unitsConsumed: string;
        acquiredAt: string;
    }>;
};
export type MarketplaceTransferListingMutationVariables = Exact<{
    input: TransferPlayerCodeListingInput;
}>;
export type MarketplaceTransferListingMutation = {
    __typename?: 'Mutation';
    transferPlayerCodeListing: {
        __typename?: 'PlayerCodeListing';
        updatedAt: string | null;
        listingId: string;
        appId: string;
        ownerKind: PlayerCodeOwnerKind;
        ownerRef: string;
        name: string;
        description: string;
        mediaJson: string;
        licenseMode: PlayerCodeLicenseMode;
        acquisitionMode: PlayerCodeAcquisitionMode;
        priceCents: number | null;
        rentIntervalDays: number | null;
        windowDays: number | null;
        unitBudget: string | null;
        status: PlayerCodeListingStatus;
        createdAt: string;
    };
};
export type MarketplaceSetListingStatusMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    listingId: Scalars['String']['input'];
    status: PlayerCodeListingStatus;
}>;
export type MarketplaceSetListingStatusMutation = {
    __typename?: 'Mutation';
    setPlayerCodeListingStatus: {
        __typename?: 'PlayerCodeListing';
        updatedAt: string | null;
        listingId: string;
        appId: string;
        ownerKind: PlayerCodeOwnerKind;
        ownerRef: string;
        name: string;
        description: string;
        mediaJson: string;
        licenseMode: PlayerCodeLicenseMode;
        acquisitionMode: PlayerCodeAcquisitionMode;
        priceCents: number | null;
        rentIntervalDays: number | null;
        windowDays: number | null;
        unitBudget: string | null;
        status: PlayerCodeListingStatus;
        createdAt: string;
    };
};
export type MarketplaceSetGridClaimPolicyMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    policy: GridClaimPolicy;
    approverUserIds?: InputMaybe<Array<Scalars['BigInt']['input']> | Scalars['BigInt']['input']>;
}>;
export type MarketplaceSetGridClaimPolicyMutation = {
    __typename?: 'Mutation';
    setAppGridClaimPolicy: GridClaimPolicy;
};
export type MarketplaceRenewAcquisitionMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    acquisitionId: Scalars['String']['input'];
}>;
export type MarketplaceRenewAcquisitionMutation = {
    __typename?: 'Mutation';
    renewPlayerCodeAcquisition: {
        __typename?: 'PlayerCodeAcquisition';
        acquisitionId: string;
        listingId: string;
        appId: string;
        mode: PlayerCodeAcquisitionMode;
        status: string;
        expiresAt: string | null;
        unitBudget: string | null;
        unitsConsumed: string;
        acquiredAt: string;
    };
};
export type MarketplaceTopUpAcquisitionMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    acquisitionId: Scalars['String']['input'];
}>;
export type MarketplaceTopUpAcquisitionMutation = {
    __typename?: 'Mutation';
    topUpPlayerCodeAcquisition: {
        __typename?: 'PlayerCodeAcquisition';
        acquisitionId: string;
        listingId: string;
        appId: string;
        mode: PlayerCodeAcquisitionMode;
        status: string;
        expiresAt: string | null;
        unitBudget: string | null;
        unitsConsumed: string;
        acquiredAt: string;
    };
};
export type MarketplaceRefundAcquisitionMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    acquisitionId: Scalars['String']['input'];
}>;
export type MarketplaceRefundAcquisitionMutation = {
    __typename?: 'Mutation';
    refundPlayerCodeAcquisition: number;
};
export type MarketplaceGridListingsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceGridListingsQuery = {
    __typename?: 'Query';
    gridListings: Array<{
        __typename?: 'GridListing';
        gridListingId: string;
        appId: string;
        kind: string;
        name: string;
        description: string;
        priceCents: number;
        conferredPermissionKeys: Array<string>;
        resalePolicy: string;
    }>;
};
export type MarketplacePurchaseGridMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridListingId: Scalars['String']['input'];
    chunkX?: InputMaybe<Scalars['Int']['input']>;
    chunkY?: InputMaybe<Scalars['Int']['input']>;
    chunkZ?: InputMaybe<Scalars['Int']['input']>;
}>;
export type MarketplacePurchaseGridMutation = {
    __typename?: 'Mutation';
    purchaseGrid: {
        __typename?: 'GridPurchaseResult';
        gridId: string;
        ownershipAssigned: boolean;
    };
};
export type MarketplaceSetListingPricingMutationVariables = Exact<{
    input: SetListingPricingInput;
}>;
export type MarketplaceSetListingPricingMutation = {
    __typename?: 'Mutation';
    setListingPricing: boolean;
};
export type MarketplaceSetOrgShareMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    bps: Scalars['Int']['input'];
}>;
export type MarketplaceSetOrgShareMutation = {
    __typename?: 'Mutation';
    setAppMarketplaceOrgShare: number;
};
export type MarketplaceBeginSellerOnboardingMutationVariables = Exact<{
    country: Scalars['String']['input'];
}>;
export type MarketplaceBeginSellerOnboardingMutation = {
    __typename?: 'Mutation';
    beginSellerOnboarding: {
        __typename?: 'SellerOnboardingLink';
        status: SellerOnboardingStatus;
        onboardingUrl: string | null;
        unavailableReason: string | null;
    };
};
export type MarketplaceCreateAccountSessionMutationVariables = Exact<{
    country: Scalars['String']['input'];
}>;
export type MarketplaceCreateAccountSessionMutation = {
    __typename?: 'Mutation';
    createSellerAccountSession: {
        __typename?: 'SellerAccountSession';
        clientSecret: string;
        publishableKey: string | null;
        accountRef: string;
        onboardingComplete: boolean;
        expiresAt: string | null;
    };
};
export type MarketplaceCreateOrgAccountSessionMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    country: Scalars['String']['input'];
}>;
export type MarketplaceCreateOrgAccountSessionMutation = {
    __typename?: 'Mutation';
    createOrgSellerAccountSession: {
        __typename?: 'SellerAccountSession';
        clientSecret: string;
        publishableKey: string | null;
        accountRef: string;
        onboardingComplete: boolean;
        expiresAt: string | null;
    };
};
export type MarketplaceBeginOrgSellerOnboardingMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    country: Scalars['String']['input'];
}>;
export type MarketplaceBeginOrgSellerOnboardingMutation = {
    __typename?: 'Mutation';
    beginOrgSellerOnboarding: {
        __typename?: 'SellerOnboardingLink';
        status: SellerOnboardingStatus;
        onboardingUrl: string | null;
        unavailableReason: string | null;
    };
};
export type MarketplaceMySellerBalanceQueryVariables = Exact<{
    [key: string]: never;
}>;
export type MarketplaceMySellerBalanceQuery = {
    __typename?: 'Query';
    mySellerPayoutBalance: {
        __typename?: 'SellerPayoutBalance';
        partyKind: string;
        partyRef: string;
        pendingCents: number;
        payableCents: number;
        reservedCents: number;
        onboardingStatus: SellerOnboardingStatus;
        payoutsFrozen: boolean;
    };
};
export type MarketplaceRequestPayoutMutationVariables = Exact<{
    [key: string]: never;
}>;
export type MarketplaceRequestPayoutMutation = {
    __typename?: 'Mutation';
    requestSellerPayout: number;
};
export type MarketplaceSpendPayoutToWalletMutationVariables = Exact<{
    amountCents: Scalars['Int']['input'];
}>;
export type MarketplaceSpendPayoutToWalletMutation = {
    __typename?: 'Mutation';
    spendPayoutBalanceToWallet: number;
};
export type MarketplaceCommerceRiskQueueQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MarketplaceCommerceRiskQueueQuery = {
    __typename?: 'Query';
    commerceRiskQueue: Array<{
        __typename?: 'CommerceRiskFlag';
        flagId: string;
        appId: string;
        kind: string;
        orderId: string | null;
        subjectKind: string;
        subjectRef: string;
        detail: string | null;
        status: string;
        createdAt: string;
    }>;
};
export type MarketplaceDecideRiskFlagMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    flagId: Scalars['String']['input'];
    release: Scalars['Boolean']['input'];
}>;
export type MarketplaceDecideRiskFlagMutation = {
    __typename?: 'Mutation';
    decideCommerceRiskFlag: boolean;
};
export type MarketplaceCreateGridListingMutationVariables = Exact<{
    input: CreateGridListingInput;
}>;
export type MarketplaceCreateGridListingMutation = {
    __typename?: 'Mutation';
    createGridListing: {
        __typename?: 'GridListing';
        gridListingId: string;
        appId: string;
        kind: string;
        name: string;
        priceCents: number;
        resalePolicy: string;
        status: string | null;
    };
};
export type CreateOrgRoleMutationVariables = Exact<{
    input: CreateOrgRoleInput;
}>;
export type CreateOrgRoleMutation = {
    __typename?: 'Mutation';
    createOrgRole: {
        __typename?: 'OrgRole';
        orgRoleId: string;
        orgId: string;
        roleName: string;
        isSystem: boolean;
        permissions: Array<string>;
        description: string | null;
    };
};
export type CreateOrgTokenMutationVariables = Exact<{
    input: CreateOrgTokenInput;
}>;
export type CreateOrgTokenMutation = {
    __typename?: 'Mutation';
    createOrgToken: {
        __typename?: 'OrgTokenWithSecret';
        orgTokenId: string;
        orgId: string;
        token: string;
        label: string | null;
        isActive: boolean;
        expiresAt: string | null;
        createdAt: string;
    };
};
export type CreateOrganizationMutationVariables = Exact<{
    input: CreateOrganizationInput;
}>;
export type CreateOrganizationMutation = {
    __typename?: 'Mutation';
    createOrganization: {
        __typename?: 'Organization';
        orgId: string;
        name: string;
        slug: string;
        ownerUserId: string;
        status: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type DeleteOrgRoleMutationVariables = Exact<{
    orgRoleId: Scalars['BigInt']['input'];
}>;
export type DeleteOrgRoleMutation = {
    __typename?: 'Mutation';
    deleteOrgRole: boolean;
};
export type InviteOrgMemberMutationVariables = Exact<{
    input: InviteOrgMemberInput;
}>;
export type InviteOrgMemberMutation = {
    __typename?: 'Mutation';
    inviteOrgMember: {
        __typename?: 'OrgMember';
        orgMemberId: string;
        orgId: string;
        userId: string;
        status: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type MemberRolesQueryVariables = Exact<{
    orgMemberId: Scalars['BigInt']['input'];
}>;
export type MemberRolesQuery = {
    __typename?: 'Query';
    memberRoles: Array<{
        __typename?: 'OrgRole';
        orgRoleId: string;
        orgId: string;
        roleName: string;
        isSystem: boolean;
        permissions: Array<string>;
        description: string | null;
    }>;
};
export type MyOrganizationsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type MyOrganizationsQuery = {
    __typename?: 'Query';
    myOrganizations: Array<{
        __typename?: 'OrgMembership';
        permissions: Array<string>;
        joinedAt: string;
        org: {
            __typename?: 'Organization';
            orgId: string;
            slug: string;
            name: string;
            ownerUserId: string;
            status: string;
            createdAt: string;
            updatedAt: string;
        };
        roles: Array<{
            __typename?: 'OrgRole';
            orgRoleId: string;
            orgId: string;
            roleName: string;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    }>;
};
export type OrgMembersQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type OrgMembersQuery = {
    __typename?: 'Query';
    orgMembers: Array<{
        __typename?: 'OrgMember';
        orgMemberId: string;
        orgId: string;
        userId: string;
        status: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type OrgPermissionsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type OrgPermissionsQuery = {
    __typename?: 'Query';
    orgPermissions: Array<{
        __typename?: 'OrgPermission';
        permissionKey: string;
        description: string | null;
        category: string | null;
    }>;
};
export type OrgRolesQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type OrgRolesQuery = {
    __typename?: 'Query';
    orgRoles: Array<{
        __typename?: 'OrgRole';
        orgRoleId: string;
        orgId: string;
        roleName: string;
        isSystem: boolean;
        permissions: Array<string>;
        description: string | null;
    }>;
};
export type OrgTokensQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type OrgTokensQuery = {
    __typename?: 'Query';
    orgTokens: Array<{
        __typename?: 'OrgToken';
        orgTokenId: string;
        orgId: string;
        label: string | null;
        isActive: boolean;
        lastUsedAt: string | null;
        revokedAt: string | null;
        expiresAt: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type OrganizationQueryVariables = Exact<{
    id: Scalars['BigInt']['input'];
}>;
export type OrganizationQuery = {
    __typename?: 'Query';
    organization: {
        __typename?: 'Organization';
        orgId: string;
        name: string;
        slug: string;
        ownerUserId: string;
        status: string;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type OrganizationBySlugQueryVariables = Exact<{
    slug: Scalars['String']['input'];
}>;
export type OrganizationBySlugQuery = {
    __typename?: 'Query';
    organizationBySlug: {
        __typename?: 'Organization';
        orgId: string;
        name: string;
        slug: string;
        ownerUserId: string;
        status: string;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type RemoveOrgMemberMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type RemoveOrgMemberMutation = {
    __typename?: 'Mutation';
    removeOrgMember: boolean;
};
export type RevokeOrgTokenMutationVariables = Exact<{
    orgTokenId: Scalars['BigInt']['input'];
}>;
export type RevokeOrgTokenMutation = {
    __typename?: 'Mutation';
    revokeOrgToken: boolean;
};
export type SetOrgStatusMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    status: Scalars['String']['input'];
}>;
export type SetOrgStatusMutation = {
    __typename?: 'Mutation';
    setOrgStatus: {
        __typename?: 'Organization';
        orgId: string;
        status: string;
        updatedAt: string;
    };
};
export type UpdateOrgMemberRolesMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
    roleIds: Array<Scalars['BigInt']['input']> | Scalars['BigInt']['input'];
}>;
export type UpdateOrgMemberRolesMutation = {
    __typename?: 'Mutation';
    updateOrgMemberRoles: {
        __typename?: 'OrgMember';
        orgMemberId: string;
        orgId: string;
        userId: string;
        status: string;
    };
};
export type UpdateOrgRoleMutationVariables = Exact<{
    orgRoleId: Scalars['BigInt']['input'];
    input: UpdateOrgRoleInput;
}>;
export type UpdateOrgRoleMutation = {
    __typename?: 'Mutation';
    updateOrgRole: {
        __typename?: 'OrgRole';
        orgRoleId: string;
        orgId: string;
        roleName: string;
        isSystem: boolean;
        permissions: Array<string>;
        description: string | null;
    };
};
export type UpdateOrgTokenMutationVariables = Exact<{
    orgTokenId: Scalars['BigInt']['input'];
    input: UpdateOrgTokenInput;
}>;
export type UpdateOrgTokenMutation = {
    __typename?: 'Mutation';
    updateOrgToken: {
        __typename?: 'OrgToken';
        orgTokenId: string;
        label: string | null;
        isActive: boolean;
        expiresAt: string | null;
        revokedAt: string | null;
        updatedAt: string;
    };
};
export type CapturePaypalCheckoutMutationVariables = Exact<{
    orderId: Scalars['String']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type CapturePaypalCheckoutMutation = {
    __typename?: 'Mutation';
    capturePaypalCheckout: {
        __typename?: 'Checkout';
        checkoutId: string;
        userId: string;
        provider: PaymentProvider;
        purpose: CheckoutPurpose;
        status: CheckoutStatus;
        amountCents: string | null;
        currency: string | null;
        externalId: string;
        externalUrl: string;
        orgId: string | null;
        appId: string | null;
        tierId: string | null;
        error: string | null;
        createdAt: string;
        completedAt: string | null;
        expiresAt: string | null;
    };
};
export type CheckoutsQueryVariables = Exact<{
    filter?: InputMaybe<CheckoutFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type CheckoutsQuery = {
    __typename?: 'Query';
    checkouts: {
        __typename?: 'CheckoutsPage';
        items: Array<{
            __typename?: 'Checkout';
            checkoutId: string;
            userId: string;
            provider: PaymentProvider;
            purpose: CheckoutPurpose;
            status: CheckoutStatus;
            amountCents: string | null;
            currency: string | null;
            externalId: string;
            externalUrl: string;
            orgId: string | null;
            appId: string | null;
            tierId: string | null;
            createdAt: string;
            completedAt: string | null;
            expiresAt: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            totalCount: number;
            limit: number;
            offset: number;
        };
    };
};
export type CheckoutsConnectionQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
    filter?: InputMaybe<CheckoutFilterInput>;
}>;
export type CheckoutsConnectionQuery = {
    __typename?: 'Query';
    checkoutsConnection: {
        __typename?: 'CheckoutsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'CheckoutEdge';
            cursor: string;
            node: {
                __typename?: 'Checkout';
                checkoutId: string;
                userId: string;
                provider: PaymentProvider;
                purpose: CheckoutPurpose;
                status: CheckoutStatus;
                amountCents: string | null;
                currency: string | null;
                externalId: string;
                externalUrl: string;
                orgId: string | null;
                appId: string | null;
                tierId: string | null;
                error: string | null;
                createdAt: string;
                completedAt: string | null;
                expiresAt: string | null;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type CreateCheckoutMutationVariables = Exact<{
    input: CreateCheckoutInput;
}>;
export type CreateCheckoutMutation = {
    __typename?: 'Mutation';
    createCheckout: {
        __typename?: 'Checkout';
        checkoutId: string;
        userId: string;
        provider: PaymentProvider;
        purpose: CheckoutPurpose;
        status: CheckoutStatus;
        amountCents: string | null;
        currency: string | null;
        externalId: string;
        externalUrl: string;
        orgId: string | null;
        appId: string | null;
        tierId: string | null;
        error: string | null;
        createdAt: string;
        completedAt: string | null;
        expiresAt: string | null;
    };
};
export type MyCheckoutsQueryVariables = Exact<{
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type MyCheckoutsQuery = {
    __typename?: 'Query';
    myCheckouts: {
        __typename?: 'CheckoutsPage';
        items: Array<{
            __typename?: 'Checkout';
            checkoutId: string;
            userId: string;
            provider: PaymentProvider;
            purpose: CheckoutPurpose;
            status: CheckoutStatus;
            amountCents: string | null;
            currency: string | null;
            externalId: string;
            externalUrl: string;
            orgId: string | null;
            appId: string | null;
            tierId: string | null;
            error: string | null;
            createdAt: string;
            completedAt: string | null;
            expiresAt: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            totalCount: number;
            limit: number;
            offset: number;
        };
    };
};
export type MyCheckoutsConnectionQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
}>;
export type MyCheckoutsConnectionQuery = {
    __typename?: 'Query';
    myCheckoutsConnection: {
        __typename?: 'CheckoutsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'CheckoutEdge';
            cursor: string;
            node: {
                __typename?: 'Checkout';
                checkoutId: string;
                userId: string;
                provider: PaymentProvider;
                purpose: CheckoutPurpose;
                status: CheckoutStatus;
                amountCents: string | null;
                currency: string | null;
                externalId: string;
                externalUrl: string;
                orgId: string | null;
                appId: string | null;
                tierId: string | null;
                error: string | null;
                createdAt: string;
                completedAt: string | null;
                expiresAt: string | null;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type PaymentEventsQueryVariables = Exact<{
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type PaymentEventsQuery = {
    __typename?: 'Query';
    paymentEvents: {
        __typename?: 'PaymentEventsPage';
        items: Array<{
            __typename?: 'PaymentEventRecord';
            eventId: string;
            provider: PaymentProvider;
            externalEventId: string;
            eventType: string;
            checkoutId: string | null;
            processedAt: string | null;
            error: string | null;
            createdAt: string;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            totalCount: number;
            limit: number;
            offset: number;
        };
    };
};
export type PaymentEventsConnectionQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
}>;
export type PaymentEventsConnectionQuery = {
    __typename?: 'Query';
    paymentEventsConnection: {
        __typename?: 'PaymentEventsConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'PaymentEventRecordEdge';
            cursor: string;
            node: {
                __typename?: 'PaymentEventRecord';
                eventId: string;
                provider: PaymentProvider;
                externalEventId: string;
                eventType: string;
                checkoutId: string | null;
                processedAt: string | null;
                error: string | null;
                createdAt: string;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type PlatformConfigQueryVariables = Exact<{
    [key: string]: never;
}>;
export type PlatformConfigQuery = {
    __typename?: 'Query';
    platformConfig: {
        __typename?: 'PlatformConfig';
        sharedGameApiUrl: string | null;
        sharedGameApiWsUrl: string | null;
        freeAppsPerOrg: number;
    };
};
export type PlayerWasmModuleFieldsFragment = {
    __typename?: 'PlayerWasmModule';
    moduleId: string;
    appId: string;
    gridId: string;
    name: string;
    description: string | null;
    authorUserId: string | null;
    authorOrgId: string | null;
    enabled: boolean;
    draft: boolean;
    currentVersionId: string | null;
    currentTarget: PlayerComputeTarget | null;
    circuitState: string;
    lastError: string | null;
    createdAt: string;
    updatedAt: string;
};
export type PlayerWasmModuleVersionFieldsFragment = {
    __typename?: 'PlayerWasmModuleVersion';
    versionId: string;
    moduleId: string;
    versionNo: number;
    target: PlayerComputeTarget;
    sourceFilesJson: string | null;
    openSource: boolean;
    compileStatus: string;
    compileLog: string | null;
    compiledSizeBytes: string | null;
    createdAt: string;
};
export type PlayerComputeDeployMutationVariables = Exact<{
    input: DeployPlayerComputeInput;
}>;
export type PlayerComputeDeployMutation = {
    __typename?: 'Mutation';
    playerComputeDeploy: {
        __typename?: 'PlayerWasmModuleVersion';
        versionId: string;
        moduleId: string;
        versionNo: number;
        target: PlayerComputeTarget;
        sourceFilesJson: string | null;
        openSource: boolean;
        compileStatus: string;
        compileLog: string | null;
        compiledSizeBytes: string | null;
        createdAt: string;
    };
};
export type PlayerComputeSetEnabledMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    enabled: Scalars['Boolean']['input'];
}>;
export type PlayerComputeSetEnabledMutation = {
    __typename?: 'Mutation';
    playerComputeSetEnabled: {
        __typename?: 'PlayerWasmModule';
        moduleId: string;
        appId: string;
        gridId: string;
        name: string;
        description: string | null;
        authorUserId: string | null;
        authorOrgId: string | null;
        enabled: boolean;
        draft: boolean;
        currentVersionId: string | null;
        currentTarget: PlayerComputeTarget | null;
        circuitState: string;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type PlayerComputeSetRequiresMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    serverName: Scalars['String']['input'];
    requiredClientName?: InputMaybe<Scalars['String']['input']>;
}>;
export type PlayerComputeSetRequiresMutation = {
    __typename?: 'Mutation';
    playerComputeSetRequires: boolean;
};
export type PlayerComputeMyModulesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type PlayerComputeMyModulesQuery = {
    __typename?: 'Query';
    playerComputeMyModules: Array<{
        __typename?: 'PlayerWasmModule';
        moduleId: string;
        appId: string;
        gridId: string;
        name: string;
        description: string | null;
        authorUserId: string | null;
        authorOrgId: string | null;
        enabled: boolean;
        draft: boolean;
        currentVersionId: string | null;
        currentTarget: PlayerComputeTarget | null;
        circuitState: string;
        lastError: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type PlayerComputeVersionsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type PlayerComputeVersionsQuery = {
    __typename?: 'Query';
    playerComputeVersions: Array<{
        __typename?: 'PlayerWasmModuleVersion';
        versionId: string;
        moduleId: string;
        versionNo: number;
        target: PlayerComputeTarget;
        sourceFilesJson: string | null;
        openSource: boolean;
        compileStatus: string;
        compileLog: string | null;
        compiledSizeBytes: string | null;
        createdAt: string;
    }>;
};
export type PlayerComputeDeleteMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
}>;
export type PlayerComputeDeleteMutation = {
    __typename?: 'Mutation';
    playerComputeDelete: boolean;
};
export type PlayerComputeInvokeMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    moduleName: Scalars['String']['input'];
    exportName: Scalars['String']['input'];
    paramsJson?: InputMaybe<Scalars['String']['input']>;
}>;
export type PlayerComputeInvokeMutation = {
    __typename?: 'Mutation';
    playerComputeInvoke: {
        __typename?: 'PlayerComputeInvokeResult';
        resultBase64: string;
        resultJson: string | null;
        fuelUsed: string;
        durationUs: number;
    };
};
export type PlayerWasmModuleRunFieldsFragment = {
    __typename?: 'PlayerWasmModuleRun';
    runId: string;
    appId: string;
    gridId: string;
    moduleId: string;
    moduleName: string;
    executedAsUserId: string;
    flowId: string | null;
    triggerSource: string;
    startedAt: string;
    durationUs: number;
    fuelUsed: string;
    success: boolean;
    errorMessage: string | null;
};
export type PlayerComputeUsageQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type PlayerComputeUsageQuery = {
    __typename?: 'Query';
    playerComputeUsage: {
        __typename?: 'PlayerComputeUsage';
        appId: string;
        hourUnitsUsed: string;
        dayUnitsUsed: string;
        unitsPerHour: string | null;
        unitsPerDay: string | null;
        compilesThisHour: number;
        maxCompilesPerHour: number;
        gateStatus: string;
        gateReason: string | null;
    };
};
export type PlayerComputeRunsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
    success?: InputMaybe<Scalars['Boolean']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type PlayerComputeRunsQuery = {
    __typename?: 'Query';
    playerComputeRuns: Array<{
        __typename?: 'PlayerWasmModuleRun';
        runId: string;
        appId: string;
        gridId: string;
        moduleId: string;
        moduleName: string;
        executedAsUserId: string;
        flowId: string | null;
        triggerSource: string;
        startedAt: string;
        durationUs: number;
        fuelUsed: string;
        success: boolean;
        errorMessage: string | null;
    }>;
};
export type PlayerComputeLogsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    moduleName?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type PlayerComputeLogsQuery = {
    __typename?: 'Query';
    playerComputeLogs: Array<{
        __typename?: 'PlayerWasmModuleRun';
        runId: string;
        appId: string;
        gridId: string;
        moduleId: string;
        moduleName: string;
        executedAsUserId: string;
        flowId: string | null;
        triggerSource: string;
        startedAt: string;
        durationUs: number;
        fuelUsed: string;
        success: boolean;
        errorMessage: string | null;
    }>;
};
export type PlayerComputeSetSwitchMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    scope: Scalars['String']['input'];
    disabled: Scalars['Boolean']['input'];
    scopeRef?: InputMaybe<Scalars['BigInt']['input']>;
    reason?: InputMaybe<Scalars['String']['input']>;
    listingRef?: InputMaybe<Scalars['String']['input']>;
}>;
export type PlayerComputeSetSwitchMutation = {
    __typename?: 'Mutation';
    playerComputeSetSwitch: boolean;
};
export type PlayerComputeSwitchesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type PlayerComputeSwitchesQuery = {
    __typename?: 'Query';
    playerComputeSwitches: Array<{
        __typename?: 'PlayerComputeSwitch';
        switchId: string;
        appId: string;
        scope: string;
        scopeRef: string | null;
        listingRef: string | null;
        reason: string | null;
        disabledAt: string;
    }>;
};
export type PlayerComputeArtifactQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
    name: Scalars['String']['input'];
    versionId?: InputMaybe<Scalars['String']['input']>;
}>;
export type PlayerComputeArtifactQuery = {
    __typename?: 'Query';
    playerComputeArtifact: {
        __typename?: 'PlayerClientArtifact';
        versionId: string;
        artifactHash: string;
        artifactBase64: string;
        sizeBytes: number;
        abiVersion: number;
        contractJson: string | null;
        clientFuelPerDispatch: string;
    };
};
export type PlayerModelContainersQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type PlayerModelContainersQuery = {
    __typename?: 'Query';
    playerModelContainers: Array<{
        __typename?: 'PlayerModelContainer';
        containerId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        typeKey: string;
        displayName: string | null;
        stateJson: string;
        propertiesJson: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type PlayerModelContainerQueryVariables = Exact<{
    input: PlayerModelContainerRefInput;
}>;
export type PlayerModelContainerQuery = {
    __typename?: 'Query';
    playerModelContainer: {
        __typename?: 'PlayerModelContainer';
        containerId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        typeKey: string;
        displayName: string | null;
        stateJson: string;
        propertiesJson: string;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type PlayerModelCreateContainerMutationVariables = Exact<{
    input: CreatePlayerModelContainerInput;
}>;
export type PlayerModelCreateContainerMutation = {
    __typename?: 'Mutation';
    playerModelCreateContainer: {
        __typename?: 'PlayerModelContainer';
        containerId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        typeKey: string;
        displayName: string | null;
        stateJson: string;
        propertiesJson: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type PlayerModelSetPropertyMutationVariables = Exact<{
    input: SetPlayerModelPropertyInput;
}>;
export type PlayerModelSetPropertyMutation = {
    __typename?: 'Mutation';
    playerModelSetProperty: {
        __typename?: 'PlayerModelContainer';
        containerId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        typeKey: string;
        displayName: string | null;
        stateJson: string;
        propertiesJson: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type PlayerModelDeleteContainerMutationVariables = Exact<{
    input: PlayerModelContainerRefInput;
}>;
export type PlayerModelDeleteContainerMutation = {
    __typename?: 'Mutation';
    playerModelDeleteContainer: boolean;
};
export type PlayerAutomationsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    gridId: Scalars['BigInt']['input'];
}>;
export type PlayerAutomationsQuery = {
    __typename?: 'Query';
    playerAutomations: Array<{
        __typename?: 'PlayerAutomation';
        automationId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        triggerJson: string;
        actionJson: string;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type PlayerAutomationCreateMutationVariables = Exact<{
    input: CreatePlayerAutomationInput;
}>;
export type PlayerAutomationCreateMutation = {
    __typename?: 'Mutation';
    playerAutomationCreate: {
        __typename?: 'PlayerAutomation';
        automationId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        triggerJson: string;
        actionJson: string;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type PlayerAutomationSetEnabledMutationVariables = Exact<{
    input: SetPlayerAutomationEnabledInput;
}>;
export type PlayerAutomationSetEnabledMutation = {
    __typename?: 'Mutation';
    playerAutomationSetEnabled: {
        __typename?: 'PlayerAutomation';
        automationId: string;
        appId: string;
        gridId: string;
        ownerUserId: string;
        name: string;
        description: string | null;
        enabled: boolean;
        triggerJson: string;
        actionJson: string;
        maxRunsPerMinute: number;
        failureThreshold: number;
        cooldownMs: number;
        circuitState: string;
        consecutiveFailures: number;
        pausedUntil: string | null;
        lastError: string | null;
        lastRunAt: string | null;
        nextRunAt: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type PlayerAutomationDeleteMutationVariables = Exact<{
    input: PlayerAutomationRefInput;
}>;
export type PlayerAutomationDeleteMutation = {
    __typename?: 'Mutation';
    playerAutomationDelete: boolean;
};
export type PlayerWalletFieldsFragment = {
    __typename?: 'PlayerWallet';
    walletId: string;
    userId: string;
    balanceCents: string;
    currency: string;
    createdAt: string;
};
export type PlayerWalletTransactionFieldsFragment = {
    __typename?: 'PlayerWalletTransaction';
    transactionId: string;
    walletId: string;
    userId: string;
    amountCents: string;
    balanceAfter: string;
    transactionType: string;
    description: string | null;
    referenceId: string | null;
    appId: string | null;
    createdAt: string;
};
export type PlayerSpendCapFieldsFragment = {
    __typename?: 'PlayerSpendCap';
    userId: string;
    scope: string;
    scopeRef: string | null;
    dailyLimitCents: string | null;
    monthlyLimitCents: string | null;
    currentDayUsageCents: string;
    currentMonthUsageCents: string;
};
export type PlayerAutoBillingFieldsFragment = {
    __typename?: 'PlayerAutoBilling';
    userId: string;
    enabled: boolean;
    limitCents: string | null;
    autoBilledThisPeriodCents: string;
    rechargeAmountCents: string;
    lowWaterThresholdCents: string;
    hasPaymentMethod: boolean;
    lastError: string | null;
};
export type PlayerUsageChargeFieldsFragment = {
    __typename?: 'PlayerUsageCharge';
    chargeId: string;
    userId: string;
    appId: string;
    periodStart: string;
    periodEnd: string;
    amountCents: string;
    platformCents: string;
    markupCents: string;
    currency: string;
    usageSnapshotJson: string;
    createdAt: string;
};
export type PlayerWasmPolicyFieldsFragment = {
    __typename?: 'PlayerWasmPolicy';
    policyId: string;
    appId: string;
    scope: string;
    scopeRef: string | null;
    enabled: boolean;
    maxModulesPerGrid: number;
    maxModulesTotal: number;
    maxTickHz: number;
    fuelPerTick: string;
    fuelPerInvoke: string;
    maxMemoryMb: number;
    maxRunMs: number;
    maxDbOpsPerTick: number;
    maxEgressMsgsPerMin: number;
    maxEgressBytesPerMin: string;
    unitsPerHour: string | null;
    unitsPerDay: string | null;
    maxCompilesPerHour: number;
    maxContainerCreatesDay: number;
    clientFuelPerDispatch: string;
};
export type PlayerWalletBalanceQueryVariables = Exact<{
    [key: string]: never;
}>;
export type PlayerWalletBalanceQuery = {
    __typename?: 'Query';
    playerWalletBalance: {
        __typename?: 'PlayerWallet';
        walletId: string;
        userId: string;
        balanceCents: string;
        currency: string;
        createdAt: string;
    };
};
export type PlayerWalletTransactionsQueryVariables = Exact<{
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type PlayerWalletTransactionsQuery = {
    __typename?: 'Query';
    playerWalletTransactions: Array<{
        __typename?: 'PlayerWalletTransaction';
        transactionId: string;
        walletId: string;
        userId: string;
        amountCents: string;
        balanceAfter: string;
        transactionType: string;
        description: string | null;
        referenceId: string | null;
        appId: string | null;
        createdAt: string;
    }>;
};
export type PlayerUsageChargesQueryVariables = Exact<{
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type PlayerUsageChargesQuery = {
    __typename?: 'Query';
    playerUsageCharges: Array<{
        __typename?: 'PlayerUsageCharge';
        chargeId: string;
        userId: string;
        appId: string;
        periodStart: string;
        periodEnd: string;
        amountCents: string;
        platformCents: string;
        markupCents: string;
        currency: string;
        usageSnapshotJson: string;
        createdAt: string;
    }>;
};
export type PlayerSpendCapsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type PlayerSpendCapsQuery = {
    __typename?: 'Query';
    playerSpendCaps: Array<{
        __typename?: 'PlayerSpendCap';
        userId: string;
        scope: string;
        scopeRef: string | null;
        dailyLimitCents: string | null;
        monthlyLimitCents: string | null;
        currentDayUsageCents: string;
        currentMonthUsageCents: string;
    }>;
};
export type SetPlayerSpendCapMutationVariables = Exact<{
    scope: Scalars['String']['input'];
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    dailyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
    monthlyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
}>;
export type SetPlayerSpendCapMutation = {
    __typename?: 'Mutation';
    setPlayerSpendCap: Array<{
        __typename?: 'PlayerSpendCap';
        userId: string;
        scope: string;
        scopeRef: string | null;
        dailyLimitCents: string | null;
        monthlyLimitCents: string | null;
        currentDayUsageCents: string;
        currentMonthUsageCents: string;
    }>;
};
export type PlayerAutoBillingQueryVariables = Exact<{
    [key: string]: never;
}>;
export type PlayerAutoBillingQuery = {
    __typename?: 'Query';
    playerAutoBilling: {
        __typename?: 'PlayerAutoBilling';
        userId: string;
        enabled: boolean;
        limitCents: string | null;
        autoBilledThisPeriodCents: string;
        rechargeAmountCents: string;
        lowWaterThresholdCents: string;
        hasPaymentMethod: boolean;
        lastError: string | null;
    };
};
export type BeginPlayerCardSetupMutationVariables = Exact<{
    [key: string]: never;
}>;
export type BeginPlayerCardSetupMutation = {
    __typename?: 'Mutation';
    beginPlayerCardSetup: {
        __typename?: 'PlayerCardSetup';
        clientSecret: string | null;
        publishableKey: string | null;
        externalCustomerId: string;
    };
};
export type SetPlayerAutoBillingMutationVariables = Exact<{
    enabled: Scalars['Boolean']['input'];
    limitCents?: InputMaybe<Scalars['BigInt']['input']>;
    rechargeAmountCents?: InputMaybe<Scalars['BigInt']['input']>;
    lowWaterThresholdCents?: InputMaybe<Scalars['BigInt']['input']>;
}>;
export type SetPlayerAutoBillingMutation = {
    __typename?: 'Mutation';
    setPlayerAutoBilling: {
        __typename?: 'PlayerAutoBilling';
        userId: string;
        enabled: boolean;
        limitCents: string | null;
        autoBilledThisPeriodCents: string;
        rechargeAmountCents: string;
        lowWaterThresholdCents: string;
        hasPaymentMethod: boolean;
        lastError: string | null;
    };
};
export type PlayerRuntimeStatesQueryVariables = Exact<{
    [key: string]: never;
}>;
export type PlayerRuntimeStatesQuery = {
    __typename?: 'Query';
    playerRuntimeStates: Array<{
        __typename?: 'PlayerRuntimeState';
        userId: string;
        appId: string;
        status: string;
        reason: string | null;
        updatedAt: string;
    }>;
};
export type PlayerWasmPoliciesQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type PlayerWasmPoliciesQuery = {
    __typename?: 'Query';
    playerWasmPolicies: Array<{
        __typename?: 'PlayerWasmPolicy';
        policyId: string;
        appId: string;
        scope: string;
        scopeRef: string | null;
        enabled: boolean;
        maxModulesPerGrid: number;
        maxModulesTotal: number;
        maxTickHz: number;
        fuelPerTick: string;
        fuelPerInvoke: string;
        maxMemoryMb: number;
        maxRunMs: number;
        maxDbOpsPerTick: number;
        maxEgressMsgsPerMin: number;
        maxEgressBytesPerMin: string;
        unitsPerHour: string | null;
        unitsPerDay: string | null;
        maxCompilesPerHour: number;
        maxContainerCreatesDay: number;
        clientFuelPerDispatch: string;
    }>;
};
export type SetPlayerWasmPolicyMutationVariables = Exact<{
    input: SetPlayerWasmPolicyInput;
}>;
export type SetPlayerWasmPolicyMutation = {
    __typename?: 'Mutation';
    setPlayerWasmPolicy: {
        __typename?: 'PlayerWasmPolicy';
        policyId: string;
        appId: string;
        scope: string;
        scopeRef: string | null;
        enabled: boolean;
        maxModulesPerGrid: number;
        maxModulesTotal: number;
        maxTickHz: number;
        fuelPerTick: string;
        fuelPerInvoke: string;
        maxMemoryMb: number;
        maxRunMs: number;
        maxDbOpsPerTick: number;
        maxEgressMsgsPerMin: number;
        maxEgressBytesPerMin: string;
        unitsPerHour: string | null;
        unitsPerDay: string | null;
        maxCompilesPerHour: number;
        maxContainerCreatesDay: number;
        clientFuelPerDispatch: string;
    };
};
export type DeletePlayerWasmPolicyMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    scope: Scalars['String']['input'];
    scopeRef?: InputMaybe<Scalars['BigInt']['input']>;
}>;
export type DeletePlayerWasmPolicyMutation = {
    __typename?: 'Mutation';
    deletePlayerWasmPolicy: boolean;
};
export type PlayerRateMarkupQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type PlayerRateMarkupQuery = {
    __typename?: 'Query';
    playerRateMarkup: number;
};
export type SetPlayerRateMarkupMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    markupBps: Scalars['Int']['input'];
}>;
export type SetPlayerRateMarkupMutation = {
    __typename?: 'Mutation';
    setPlayerRateMarkup: number;
};
export type AppPlayerUsageQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    hours?: InputMaybe<Scalars['Int']['input']>;
}>;
export type AppPlayerUsageQuery = {
    __typename?: 'Query';
    appPlayerUsage: Array<{
        __typename?: 'AppPlayerUsageRow';
        userId: string;
        computeUnits: string;
        automationUnits: string;
        compileCount: number;
        chargedCents: string;
    }>;
};
export type AppPlayerMarkupAccruedQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppPlayerMarkupAccruedQuery = {
    __typename?: 'Query';
    appPlayerMarkupAccrued: string;
};
export type DeleteQuotaMutationVariables = Exact<{
    quotaId: Scalars['BigInt']['input'];
}>;
export type DeleteQuotaMutation = {
    __typename?: 'Mutation';
    deleteQuota: boolean;
};
export type EffectiveQuotaQueryVariables = Exact<{
    metric: Scalars['String']['input'];
    orgId?: InputMaybe<Scalars['BigInt']['input']>;
    appId?: InputMaybe<Scalars['BigInt']['input']>;
    tierId?: InputMaybe<Scalars['BigInt']['input']>;
}>;
export type EffectiveQuotaQuery = {
    __typename?: 'Query';
    effectiveQuota: {
        __typename?: 'ServiceQuota';
        quotaId: string;
        orgId: string | null;
        appId: string | null;
        tierId: string | null;
        metric: string;
        limitValue: string;
        period: string;
        actionOnExceed: string;
    } | null;
};
export type QuotasForAppQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type QuotasForAppQuery = {
    __typename?: 'Query';
    quotasForApp: Array<{
        __typename?: 'ServiceQuota';
        quotaId: string;
        orgId: string | null;
        appId: string | null;
        tierId: string | null;
        metric: string;
        limitValue: string;
        period: string;
        actionOnExceed: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type QuotasForOrgQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type QuotasForOrgQuery = {
    __typename?: 'Query';
    quotasForOrg: Array<{
        __typename?: 'ServiceQuota';
        quotaId: string;
        orgId: string | null;
        appId: string | null;
        tierId: string | null;
        metric: string;
        limitValue: string;
        period: string;
        actionOnExceed: string;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type SetQuotaMutationVariables = Exact<{
    input: SetQuotaInput;
}>;
export type SetQuotaMutation = {
    __typename?: 'Mutation';
    setQuota: {
        __typename?: 'ServiceQuota';
        quotaId: string;
        orgId: string | null;
        appId: string | null;
        tierId: string | null;
        metric: string;
        limitValue: string;
        period: string;
        actionOnExceed: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type ActiveGraphQlServersQueryVariables = Exact<{
    [key: string]: never;
}>;
export type ActiveGraphQlServersQuery = {
    __typename?: 'Query';
    activeGraphQLServers: Array<{
        __typename?: 'GraphQLServer';
        graphqlServerId: string;
        ip4: string | null;
        ip6: string | null;
        status: ServerState;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type GameClientBootstrapQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type GameClientBootstrapQuery = {
    __typename?: 'Query';
    gameClientBootstrap: {
        __typename?: 'GameClientBootstrap';
        appId: string;
        gameApiUrl: string | null;
        gameApiWsUrl: string | null;
        discoveryUrl: string | null;
        realtimeProtocol: string;
        subscriptionName: string;
        maxReplicationDistance: number;
        maxDecayRate: number;
        sequenceNumberModulo: number;
        udpProxyConnectionStatus: {
            __typename?: 'UdpProxyConnectionStatus';
            connected: boolean;
            serverIp6: string | null;
            serverClientPort: number | null;
            lastMessageTime: string | null;
        };
        versionInfo: {
            __typename?: 'ServerVersionInfo';
            serverVersion: {
                __typename?: 'VersionInfo';
                major: number;
                minor: number;
                patch: number;
                build: number;
            };
            minimumClientVersion: {
                __typename?: 'VersionInfo';
                major: number;
                minor: number;
                patch: number;
                build: number;
            };
        };
        me: {
            __typename?: 'User';
            userId: string;
            email: string | null;
            gamertag: string | null;
            disambiguation: string | null;
            state: string | null;
            isConfirmed: boolean;
            createdAt: string;
            grantEarlyAccess: boolean;
            grantEarlyAccessOverride: boolean;
            orgId: string | null;
            externalId: string | null;
            userType: string;
            isSuperAdmin: boolean;
        };
    };
};
export type GraphqlServersQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GraphqlServersQuery = {
    __typename?: 'Query';
    graphqlServers: Array<{
        __typename?: 'GraphQLServer';
        graphqlServerId: string;
        ip4: string | null;
        ip6: string | null;
        status: ServerState;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type ServerWithLeastClientsQueryVariables = Exact<{
    [key: string]: never;
}>;
export type ServerWithLeastClientsQuery = {
    __typename?: 'Query';
    serverWithLeastClients: {
        __typename?: 'ServerStatus';
        serverId: string;
        ip4: string;
        ip6: string;
        clientPort: number;
        status: ServerState;
        peers: number;
        clients: number;
        cpuPeakPct: number | null;
        updatedAt: string;
        createdAt: string;
    };
};
export type VersionInfoQueryVariables = Exact<{
    [key: string]: never;
}>;
export type VersionInfoQuery = {
    __typename?: 'Query';
    versionInfo: {
        __typename?: 'ServerVersionInfo';
        serverVersion: {
            __typename?: 'VersionInfo';
            major: number;
            minor: number;
            patch: number;
            build: number;
        };
        minimumClientVersion: {
            __typename?: 'VersionInfo';
            major: number;
            minor: number;
            patch: number;
            build: number;
        };
    };
};
export type SharedEnvPlansQueryVariables = Exact<{
    [key: string]: never;
}>;
export type SharedEnvPlansQuery = {
    __typename?: 'Query';
    sharedEnvPlans: Array<{
        __typename?: 'SharedEnvPlan';
        planId: string;
        code: string;
        name: string;
        description: string | null;
        priceCents: string;
        currency: string;
        billingInterval: string;
        status: string;
    }>;
};
export type OrgFreeAppQuotaQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type OrgFreeAppQuotaQuery = {
    __typename?: 'Query';
    orgFreeAppQuota: {
        __typename?: 'FreeAppQuota';
        orgId: string;
        quota: number;
        usedFree: number;
        paidApps: number;
        remainingFree: number;
    };
};
export type AppSharedSubscriptionQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppSharedSubscriptionQuery = {
    __typename?: 'Query';
    appSharedSubscription: {
        __typename?: 'AppSharedSubscription';
        appId: string;
        orgId: string;
        planId: string | null;
        provider: string | null;
        status: string;
        currentPeriodEnd: string | null;
    } | null;
};
export type AppRuntimeStateQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type AppRuntimeStateQuery = {
    __typename?: 'Query';
    appRuntimeState: {
        __typename?: 'AppRuntimeState';
        appId: string;
        deploymentTarget: AppDeploymentTarget;
        runtimeStatus: AppRuntimeStatus;
        runtimeDenialReason: string | null;
        walletBalanceCents: string;
        currentHourUsageCents: string;
        currentDayUsageCents: string;
        hourlyLimitCents: string | null;
        dailyLimitCents: string | null;
    };
};
export type OrgAutoBillingQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type OrgAutoBillingQuery = {
    __typename?: 'Query';
    orgAutoBilling: {
        __typename?: 'OrgAutoBilling';
        orgId: string;
        enabled: boolean;
        limitCents: string | null;
        period: string;
        autoBilledThisPeriodCents: string;
        rechargeAmountCents: string;
        lowWaterThresholdCents: string;
        hasPaymentMethod: boolean;
        lastError: string | null;
    };
};
export type OrgPaymentMethodsQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type OrgPaymentMethodsQuery = {
    __typename?: 'Query';
    orgPaymentMethods: Array<{
        __typename?: 'SavedPaymentMethod';
        paymentMethodId: string;
        provider: string;
        brand: string | null;
        last4: string | null;
        isDefault: boolean;
        status: string;
    }>;
};
export type PublishAppToSharedMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    planId?: InputMaybe<Scalars['BigInt']['input']>;
    provider?: InputMaybe<PaymentProvider>;
    successUrl?: InputMaybe<Scalars['String']['input']>;
    cancelUrl?: InputMaybe<Scalars['String']['input']>;
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type PublishAppToSharedMutation = {
    __typename?: 'Mutation';
    publishAppToShared: {
        __typename?: 'PublishAppResult';
        appId: string;
        free: boolean;
        checkout: {
            __typename?: 'Checkout';
            checkoutId: string;
            provider: PaymentProvider;
            status: CheckoutStatus;
            amountCents: string | null;
            currency: string | null;
            externalUrl: string;
        } | null;
    };
};
export type CancelSharedSubscriptionMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type CancelSharedSubscriptionMutation = {
    __typename?: 'Mutation';
    cancelSharedSubscription: {
        __typename?: 'AppSharedSubscription';
        appId: string;
        orgId: string;
        planId: string | null;
        provider: string | null;
        status: string;
        currentPeriodEnd: string | null;
    };
};
export type SetAppSpendCapsMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    hourlyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
    dailyLimitCents?: InputMaybe<Scalars['BigInt']['input']>;
}>;
export type SetAppSpendCapsMutation = {
    __typename?: 'Mutation';
    setAppSpendCaps: {
        __typename?: 'AppRuntimeState';
        appId: string;
        runtimeStatus: AppRuntimeStatus;
        runtimeDenialReason: string | null;
        hourlyLimitCents: string | null;
        dailyLimitCents: string | null;
    };
};
export type SetAutoBillingMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    enabled: Scalars['Boolean']['input'];
    limitCents?: InputMaybe<Scalars['BigInt']['input']>;
    rechargeAmountCents?: InputMaybe<Scalars['BigInt']['input']>;
    lowWaterThresholdCents?: InputMaybe<Scalars['BigInt']['input']>;
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type SetAutoBillingMutation = {
    __typename?: 'Mutation';
    setAutoBilling: {
        __typename?: 'OrgAutoBilling';
        orgId: string;
        enabled: boolean;
        limitCents: string | null;
        rechargeAmountCents: string;
        lowWaterThresholdCents: string;
        hasPaymentMethod: boolean;
    };
};
export type SetupSharedPaymentMethodMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type SetupSharedPaymentMethodMutation = {
    __typename?: 'Mutation';
    setupSharedPaymentMethod: {
        __typename?: 'PaymentMethodSetup';
        externalCustomerId: string;
        clientSecret: string | null;
        publishableKey: string | null;
    };
};
export type RemoveSharedPaymentMethodMutationVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    paymentMethodId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type RemoveSharedPaymentMethodMutation = {
    __typename?: 'Mutation';
    removeSharedPaymentMethod: boolean;
};
export type DeleteUserAppStateMutationVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type DeleteUserAppStateMutation = {
    __typename?: 'Mutation';
    deleteUserAppState: {
        __typename?: 'UserAppState';
        userId: string;
        appId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateUserAppStateMutationVariables = Exact<{
    input: CreateUserAppStateInput;
}>;
export type UpdateUserAppStateMutation = {
    __typename?: 'Mutation';
    updateUserAppState: {
        __typename?: 'UserAppState';
        userId: string;
        appId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type UserAppStateQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type UserAppStateQuery = {
    __typename?: 'Query';
    userAppState: {
        __typename?: 'UserAppState';
        userId: string;
        appId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    } | null;
};
export type UserAppStatesQueryVariables = Exact<{
    [key: string]: never;
}>;
export type UserAppStatesQuery = {
    __typename?: 'Query';
    userAppStates: Array<{
        __typename?: 'UserAppState';
        userId: string;
        appId: string;
        state: string | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type AddTeamMemberMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type AddTeamMemberMutation = {
    __typename?: 'Mutation';
    addTeamMember: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type CreateTeamMutationVariables = Exact<{
    input: CreateTeamInput;
}>;
export type CreateTeamMutation = {
    __typename?: 'Mutation';
    createTeam: {
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    };
};
export type CreateTeamRoleMutationVariables = Exact<{
    input: CreateGroupRoleInput;
}>;
export type CreateTeamRoleMutation = {
    __typename?: 'Mutation';
    createTeamRole: {
        __typename?: 'GroupRole';
        groupRoleId: string;
        groupId: string;
        roleName: string;
        rank: number;
        isSystem: boolean;
        permissions: Array<string>;
        createdAt: string;
    };
};
export type DeleteTeamMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type DeleteTeamMutation = {
    __typename?: 'Mutation';
    deleteTeam: boolean;
};
export type DeleteTeamRoleMutationVariables = Exact<{
    groupRoleId: Scalars['BigInt']['input'];
}>;
export type DeleteTeamRoleMutation = {
    __typename?: 'Mutation';
    deleteTeamRole: boolean;
};
export type JoinTeamMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type JoinTeamMutation = {
    __typename?: 'Mutation';
    joinTeam: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type LeaveTeamMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
    idempotencyKey?: InputMaybe<Scalars['String']['input']>;
}>;
export type LeaveTeamMutation = {
    __typename?: 'Mutation';
    leaveTeam: boolean;
};
export type MyTeamsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type MyTeamsQuery = {
    __typename?: 'Query';
    myTeams: Array<{
        __typename?: 'GroupMembership';
        permissions: Array<string>;
        joinedAt: string;
        group: {
            __typename?: 'Group';
            groupId: string;
            appId: string;
            groupType: string;
            name: string;
            description: string | null;
            ownerUserId: string | null;
            membershipPolicy: string;
            status: string;
            defaultRoleId: string | null;
            createdAt: string;
        };
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    }>;
};
export type RemoveTeamMemberMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
    userId: Scalars['BigInt']['input'];
}>;
export type RemoveTeamMemberMutation = {
    __typename?: 'Mutation';
    removeTeamMember: boolean;
};
export type RequestToJoinTeamMutationVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type RequestToJoinTeamMutation = {
    __typename?: 'Mutation';
    requestToJoinTeam: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type SetTeamMemberRolesMutationVariables = Exact<{
    input: SetMemberRolesInput;
}>;
export type SetTeamMemberRolesMutation = {
    __typename?: 'Mutation';
    setTeamMemberRoles: {
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    };
};
export type SetTeamPolicyMutationVariables = Exact<{
    input: SetTeamPolicyInput;
}>;
export type SetTeamPolicyMutation = {
    __typename?: 'Mutation';
    setTeamPolicy: {
        __typename?: 'AppGroupPolicy';
        appId: string;
        groupType: string;
        creationPolicy: string;
        defaultMembershipPolicy: string;
        maxMembers: number | null;
        maxGroupsPerUser: number | null;
    };
};
export type TeamQueryVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type TeamQuery = {
    __typename?: 'Query';
    team: {
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    };
};
export type TeamMembersQueryVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type TeamMembersQuery = {
    __typename?: 'Query';
    teamMembers: Array<{
        __typename?: 'GroupMember';
        groupMemberId: string;
        groupId: string;
        userId: string;
        status: string;
        createdAt: string;
        roles: Array<{
            __typename?: 'GroupRole';
            groupRoleId: string;
            roleName: string;
            rank: number;
            isSystem: boolean;
            permissions: Array<string>;
        }>;
    }>;
};
export type TeamPolicyQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type TeamPolicyQuery = {
    __typename?: 'Query';
    teamPolicy: {
        __typename?: 'AppGroupPolicy';
        appId: string;
        groupType: string;
        creationPolicy: string;
        defaultMembershipPolicy: string;
        maxMembers: number | null;
        maxGroupsPerUser: number | null;
    };
};
export type TeamRolesQueryVariables = Exact<{
    groupId: Scalars['BigInt']['input'];
}>;
export type TeamRolesQuery = {
    __typename?: 'Query';
    teamRoles: Array<{
        __typename?: 'GroupRole';
        groupRoleId: string;
        groupId: string;
        roleName: string;
        rank: number;
        isSystem: boolean;
        permissions: Array<string>;
        createdAt: string;
    }>;
};
export type TeamsQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
}>;
export type TeamsQuery = {
    __typename?: 'Query';
    teams: Array<{
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    }>;
};
export type UpdateTeamMutationVariables = Exact<{
    input: UpdateTeamInput;
}>;
export type UpdateTeamMutation = {
    __typename?: 'Mutation';
    updateTeam: {
        __typename?: 'Group';
        groupId: string;
        appId: string;
        groupType: string;
        name: string;
        description: string | null;
        ownerUserId: string | null;
        membershipPolicy: string;
        status: string;
        defaultRoleId: string | null;
        createdAt: string;
    };
};
export type UpdateTeamRoleMutationVariables = Exact<{
    input: UpdateGroupRoleInput;
}>;
export type UpdateTeamRoleMutation = {
    __typename?: 'Mutation';
    updateTeamRole: {
        __typename?: 'GroupRole';
        groupRoleId: string;
        groupId: string;
        roleName: string;
        rank: number;
        isSystem: boolean;
        permissions: Array<string>;
        createdAt: string;
    };
};
export type TeleportRequestMutationVariables = Exact<{
    input: TeleportRequestInput;
}>;
export type TeleportRequestMutation = {
    __typename?: 'Mutation';
    teleportRequest: {
        __typename?: 'TeleportResponse';
        success: boolean;
        errorCode: UdpErrorCode;
    };
};
export type ConnectUdpProxyMutationVariables = Exact<{
    [key: string]: never;
}>;
export type ConnectUdpProxyMutation = {
    __typename?: 'Mutation';
    connectUdpProxy: {
        __typename?: 'UdpProxyConnectionStatus';
        connected: boolean;
        serverIp6: string | null;
        serverClientPort: number | null;
        lastMessageTime: string | null;
    };
};
export type DisconnectUdpProxyMutationVariables = Exact<{
    [key: string]: never;
}>;
export type DisconnectUdpProxyMutation = {
    __typename?: 'Mutation';
    disconnectUdpProxy: boolean;
};
export type SendActorUpdateMutationVariables = Exact<{
    input: ActorUpdateRequestInput;
}>;
export type SendActorUpdateMutation = {
    __typename?: 'Mutation';
    sendActorUpdate: boolean;
};
export type SendAudioPacketMutationVariables = Exact<{
    input: ClientAudioPacketInput;
}>;
export type SendAudioPacketMutation = {
    __typename?: 'Mutation';
    sendAudioPacket: boolean;
};
export type SendChannelMessageMutationVariables = Exact<{
    input: ChannelMessageInput;
}>;
export type SendChannelMessageMutation = {
    __typename?: 'Mutation';
    sendChannelMessage: boolean;
};
export type SendClientEventMutationVariables = Exact<{
    input: ClientEventNotificationInput;
}>;
export type SendClientEventMutation = {
    __typename?: 'Mutation';
    sendClientEvent: boolean;
};
export type SendSingleActorMessageMutationVariables = Exact<{
    input: SingleActorMessageInput;
}>;
export type SendSingleActorMessageMutation = {
    __typename?: 'Mutation';
    sendSingleActorMessage: boolean;
};
export type SendTextPacketMutationVariables = Exact<{
    input: ClientTextPacketInput;
}>;
export type SendTextPacketMutation = {
    __typename?: 'Mutation';
    sendTextPacket: boolean;
};
export type SendVoxelUpdateMutationVariables = Exact<{
    input: VoxelUpdateRequestInput;
}>;
export type SendVoxelUpdateMutation = {
    __typename?: 'Mutation';
    sendVoxelUpdate: boolean;
};
export type UdpNotificationsSubscriptionVariables = Exact<{
    [key: string]: never;
}>;
export type UdpNotificationsSubscription = {
    __typename?: 'Subscription';
    udpNotifications: {
        __typename: 'ActorUpdateNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        state: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'ActorUpdateResponse';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'ChannelMessageNotification';
        channelId: string;
        uuid: string;
        payload: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'ClientAudioNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        audioData: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'ClientEventNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        eventType: number;
        state: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'ClientTextNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        text: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'GenericErrorResponse';
        sequenceNumber: number;
        errorCode: UdpErrorCode;
    } | {
        __typename: 'RealtimeConnectionEvent';
        status: string;
        code: string;
        message: string;
        retryable: boolean;
    } | {
        __typename: 'ServerEventNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        eventType: number;
        state: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'SingleActorMessageNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        uuid: string;
        payload: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'VoxelUpdateNotification';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        voxelX: number;
        voxelY: number;
        voxelZ: number;
        voxelType: number;
        voxelState: string;
        sequenceNumber: number;
        epochMillis: string;
    } | {
        __typename: 'VoxelUpdateResponse';
        appId: string;
        chunkX: string;
        chunkY: string;
        chunkZ: string;
        distance: number;
        decayRate: number;
        uuid: string;
        sequenceNumber: number;
        epochMillis: string;
    } | null;
};
export type UdpProxyConnectionStatusQueryVariables = Exact<{
    [key: string]: never;
}>;
export type UdpProxyConnectionStatusQuery = {
    __typename?: 'Query';
    udpProxyConnectionStatus: {
        __typename?: 'UdpProxyConnectionStatus';
        connected: boolean;
        serverIp6: string | null;
        serverClientPort: number | null;
        lastMessageTime: string | null;
    };
};
export type AppGraphqlOperationsQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    appId: Scalars['BigInt']['input'];
    since: Scalars['DateTime']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type AppGraphqlOperationsQuery = {
    __typename?: 'Query';
    appGraphqlOperations: Array<{
        __typename?: 'GraphqlOperationUsageRow';
        operationName: string;
        totalOps: string;
        sendBytes: string;
        recvBytes: string;
    }>;
};
export type AppUsageSummaryQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
    appId: Scalars['BigInt']['input'];
    since: Scalars['DateTime']['input'];
    operationLimit?: InputMaybe<Scalars['Int']['input']>;
}>;
export type AppUsageSummaryQuery = {
    __typename?: 'Query';
    appUsageSummary: {
        __typename?: 'AppUsageSummary';
        appId: string;
        replicationSendBytes: string;
        replicationRecvBytes: string;
        graphqlSendBytes: string;
        graphqlRecvBytes: string;
        automationRuns: string;
        automationInvocations: string;
        automationComputeUnits: string;
        topGraphqlOperations: Array<{
            __typename?: 'GraphqlOperationUsageRow';
            operationName: string;
            totalOps: string;
            sendBytes: string;
            recvBytes: string;
        }>;
    };
};
export type PlayerPulseQueryVariables = Exact<{
    orgId: Scalars['BigInt']['input'];
}>;
export type PlayerPulseQuery = {
    __typename?: 'Query';
    playerPulse: {
        __typename?: 'PlayerPulse';
        orgLivePlayers: number;
        orgAllTimePeak: number;
        orgAllTimePeakAt: string | null;
        globalLivePlayers: number;
        percentile: number | null;
        poolSize: number;
    };
};
export type DeleteMyAccountMutationVariables = Exact<{
    [key: string]: never;
}>;
export type DeleteMyAccountMutation = {
    __typename?: 'Mutation';
    deleteMyAccount: boolean;
};
export type ForceLogoutUserMutationVariables = Exact<{
    userId: Scalars['BigInt']['input'];
}>;
export type ForceLogoutUserMutation = {
    __typename?: 'Mutation';
    forceLogoutUser: boolean;
};
export type FreePlayWindowQueryVariables = Exact<{
    [key: string]: never;
}>;
export type FreePlayWindowQuery = {
    __typename?: 'Query';
    freePlayWindowInfo: {
        __typename?: 'FreePlayWindowInfo';
        isCurrentlyActive: boolean;
        description: string;
        nextWindowStart: string | null;
    };
};
export type MeQueryVariables = Exact<{
    [key: string]: never;
}>;
export type MeQuery = {
    __typename?: 'Query';
    me: {
        __typename?: 'User';
        userId: string;
        email: string | null;
        gamertag: string | null;
        disambiguation: string | null;
        state: string | null;
        isConfirmed: boolean;
        createdAt: string;
        grantEarlyAccess: boolean;
        grantEarlyAccessOverride: boolean;
        orgId: string | null;
        externalId: string | null;
        userType: string;
        isSuperAdmin: boolean;
    } | null;
};
export type SetEarlyAccessOverrideMutationVariables = Exact<{
    userId: Scalars['BigInt']['input'];
    value: Scalars['Boolean']['input'];
}>;
export type SetEarlyAccessOverrideMutation = {
    __typename?: 'Mutation';
    setEarlyAccessOverride: {
        __typename?: 'User';
        userId: string;
        grantEarlyAccessOverride: boolean;
    };
};
export type SetOperatorMutationVariables = Exact<{
    userId: Scalars['BigInt']['input'];
    value: Scalars['Boolean']['input'];
}>;
export type SetOperatorMutation = {
    __typename?: 'Mutation';
    setOperator: {
        __typename?: 'User';
        userId: string;
        isOperator: boolean;
        isSuperAdmin: boolean;
    };
};
export type SetSuperAdminMutationVariables = Exact<{
    userId: Scalars['BigInt']['input'];
    value: Scalars['Boolean']['input'];
}>;
export type SetSuperAdminMutation = {
    __typename?: 'Mutation';
    setSuperAdmin: {
        __typename?: 'User';
        userId: string;
        isSuperAdmin: boolean;
    };
};
export type UpdateGamertagMutationVariables = Exact<{
    input: UpdateGamertagInput;
}>;
export type UpdateGamertagMutation = {
    __typename?: 'Mutation';
    updateGamertag: {
        __typename?: 'User';
        userId: string;
        gamertag: string | null;
        disambiguation: string | null;
        userType: string;
    };
};
export type UpdateUserStateMutationVariables = Exact<{
    input: UpdateUserStateInput;
}>;
export type UpdateUserStateMutation = {
    __typename?: 'Mutation';
    updateUserState: {
        __typename?: 'User';
        userId: string;
        state: string | null;
        userType: string;
    };
};
export type UpdateUserTypeMutationVariables = Exact<{
    userId: Scalars['BigInt']['input'];
    value: Scalars['String']['input'];
}>;
export type UpdateUserTypeMutation = {
    __typename?: 'Mutation';
    updateUserType: {
        __typename?: 'User';
        userId: string;
        userType: string;
    };
};
export type UserQueryVariables = Exact<{
    id: Scalars['BigInt']['input'];
}>;
export type UserQuery = {
    __typename?: 'Query';
    user: {
        __typename?: 'User';
        userId: string;
        email: string | null;
        gamertag: string | null;
        disambiguation: string | null;
        state: string | null;
        isConfirmed: boolean;
        createdAt: string;
        grantEarlyAccess: boolean;
        grantEarlyAccessOverride: boolean;
        orgId: string | null;
        externalId: string | null;
        userType: string;
        isSuperAdmin: boolean;
    } | null;
};
export type UsersPaginatedQueryVariables = Exact<{
    query?: InputMaybe<Scalars['String']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type UsersPaginatedQuery = {
    __typename?: 'Query';
    usersPaginated: {
        __typename?: 'UsersPage';
        items: Array<{
            __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;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            totalCount: number;
            limit: number;
            offset: number;
        };
    };
};
export type UsersConnectionQueryVariables = Exact<{
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
    query?: InputMaybe<Scalars['String']['input']>;
}>;
export type UsersConnectionQuery = {
    __typename?: 'Query';
    usersConnection: {
        __typename?: 'UsersConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'UserEdge';
            cursor: string;
            node: {
                __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;
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export type ListVoxelUpdatesByDistanceQueryVariables = Exact<{
    input: ListVoxelUpdatesByDistanceInput;
}>;
export type ListVoxelUpdatesByDistanceQuery = {
    __typename?: 'Query';
    listVoxelUpdatesByDistance: {
        __typename?: 'VoxelUpdatesByDistanceResponse';
        limit: number | null;
        skip: number | null;
        centerCoordinate: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        chunks: Array<{
            __typename?: 'ChunkVoxelUpdatesResponse';
            coordinates: {
                __typename?: 'ChunkCoordinates';
                x: string;
                y: string;
                z: string;
            };
            voxels: Array<{
                __typename?: 'Voxel';
                voxelUpdateId: string;
                appId: string;
                voxelType: number;
                state: string | null;
                createdBy: string;
                createdAt: string;
                location: {
                    __typename?: 'VoxelCoordinates';
                    x: number;
                    y: number;
                    z: number;
                };
            }>;
        }>;
    };
};
export type ListVoxelsQueryVariables = Exact<{
    input: ListVoxelsInput;
}>;
export type ListVoxelsQuery = {
    __typename?: 'Query';
    listVoxels: Array<{
        __typename?: 'Voxel';
        voxelUpdateId: string;
        appId: string;
        voxelType: number;
        state: string | null;
        createdBy: string;
        createdAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        location: {
            __typename?: 'VoxelCoordinates';
            x: number;
            y: number;
            z: number;
        };
    }>;
};
export type RollbackVoxelUpdatesMutationVariables = Exact<{
    input: RollbackVoxelUpdatesInput;
}>;
export type RollbackVoxelUpdatesMutation = {
    __typename?: 'Mutation';
    rollbackVoxelUpdates: Array<{
        __typename?: 'RollbackVoxelEventResult';
        appId: string;
        fromVoxelType: number | null;
        toVoxelType: number | null;
        plannedAction: string;
        applied: boolean;
        reason: string | null;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        location: {
            __typename?: 'VoxelCoordinates';
            x: number;
            y: number;
            z: number;
        };
    }>;
};
export type UpdateVoxelMutationVariables = Exact<{
    input: UpdateVoxelInput;
}>;
export type UpdateVoxelMutation = {
    __typename?: 'Mutation';
    updateVoxel: {
        __typename?: 'Voxel';
        voxelUpdateId: string;
        appId: string;
        voxelType: number;
        state: string | null;
        createdBy: string;
        createdAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        location: {
            __typename?: 'VoxelCoordinates';
            x: number;
            y: number;
            z: number;
        };
    };
};
export type VoxelUpdateHistoryQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    userId?: InputMaybe<Scalars['BigInt']['input']>;
    from?: InputMaybe<Scalars['DateTime']['input']>;
    to?: InputMaybe<Scalars['DateTime']['input']>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
}>;
export type VoxelUpdateHistoryQuery = {
    __typename?: 'Query';
    voxelUpdateHistory: Array<{
        __typename?: 'VoxelUpdateHistoryEvent';
        id: string;
        appId: string;
        oldVoxelType: number | null;
        newVoxelType: number | null;
        changedBy: string | null;
        changedAt: string;
        coordinates: {
            __typename?: 'ChunkCoordinates';
            x: string;
            y: string;
            z: string;
        };
        location: {
            __typename?: 'VoxelCoordinates';
            x: number;
            y: number;
            z: number;
        };
    }>;
};
export type VoxelUpdateHistoryConnectionQueryVariables = Exact<{
    appId: Scalars['BigInt']['input'];
    userId?: InputMaybe<Scalars['BigInt']['input']>;
    from?: InputMaybe<Scalars['DateTime']['input']>;
    to?: InputMaybe<Scalars['DateTime']['input']>;
    first?: InputMaybe<Scalars['Int']['input']>;
    after?: InputMaybe<Scalars['String']['input']>;
}>;
export type VoxelUpdateHistoryConnectionQuery = {
    __typename?: 'Query';
    voxelUpdateHistoryConnection: {
        __typename?: 'VoxelUpdateHistoryConnection';
        totalCount: number | null;
        edges: Array<{
            __typename?: 'VoxelUpdateHistoryEventEdge';
            cursor: string;
            node: {
                __typename?: 'VoxelUpdateHistoryEvent';
                id: string;
                appId: string;
                oldVoxelType: number | null;
                newVoxelType: number | null;
                changedBy: string | null;
                changedAt: string;
                coordinates: {
                    __typename?: 'ChunkCoordinates';
                    x: string;
                    y: string;
                    z: string;
                };
                location: {
                    __typename?: 'VoxelCoordinates';
                    x: number;
                    y: number;
                    z: number;
                };
            };
        }>;
        pageInfo: {
            __typename?: 'ConnectionPageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor: string | null;
            endCursor: string | null;
        };
    };
};
export declare const AppCodeAdmissionFieldsFragmentDoc: DocumentNode<AppCodeAdmissionFieldsFragment, unknown>;
export declare const ComputeModuleFieldsFragmentDoc: DocumentNode<ComputeModuleFieldsFragment, unknown>;
export declare const ComputeVersionFieldsFragmentDoc: DocumentNode<ComputeVersionFieldsFragment, unknown>;
export declare const ComputeTriggerFieldsFragmentDoc: DocumentNode<ComputeTriggerFieldsFragment, unknown>;
export declare const ComputePolicyFieldsFragmentDoc: DocumentNode<ComputePolicyFieldsFragment, unknown>;
export declare const ComputeRunFieldsFragmentDoc: DocumentNode<ComputeRunFieldsFragment, unknown>;
export declare const CrowdyStudioProjectFieldsFragmentDoc: DocumentNode<CrowdyStudioProjectFieldsFragment, unknown>;
export declare const CrowdyAgentRunFieldsFragmentDoc: DocumentNode<CrowdyAgentRunFieldsFragment, unknown>;
export declare const CrowdyAgentLeaseFieldsFragmentDoc: DocumentNode<CrowdyAgentLeaseFieldsFragment, unknown>;
export declare const CrowdyAgentApprovalFieldsFragmentDoc: DocumentNode<CrowdyAgentApprovalFieldsFragment, unknown>;
export declare const CrowdyAgentSessionFieldsFragmentDoc: DocumentNode<CrowdyAgentSessionFieldsFragment, unknown>;
export declare const CrowdyAgentToolDescriptorFieldsFragmentDoc: DocumentNode<CrowdyAgentToolDescriptorFieldsFragment, unknown>;
export declare const CrowdyAgentEventBaseFieldsFragmentDoc: DocumentNode<CrowdyAgentEventBaseFieldsFragment, unknown>;
export declare const CrowdyAgentErrorFieldsFragmentDoc: DocumentNode<CrowdyAgentErrorFieldsFragment, unknown>;
export declare const CrowdyAgentBudgetFieldsFragmentDoc: DocumentNode<CrowdyAgentBudgetFieldsFragment, unknown>;
export declare const CrowdyAgentEventFieldsFragmentDoc: DocumentNode<CrowdyAgentEventFieldsFragment, unknown>;
export declare const GridOwnershipFieldsFragmentDoc: DocumentNode<GridOwnershipFieldsFragment, unknown>;
export declare const GmAutomationFieldsFragmentDoc: DocumentNode<GmAutomationFieldsFragment, unknown>;
export declare const GmAutomationTriggerFieldsFragmentDoc: DocumentNode<GmAutomationTriggerFieldsFragment, unknown>;
export declare const GmAutomationPolicyFieldsFragmentDoc: DocumentNode<GmAutomationPolicyFieldsFragment, unknown>;
export declare const GmAutomationRunFieldsFragmentDoc: DocumentNode<GmAutomationRunFieldsFragment, unknown>;
export declare const GmTimerFieldsFragmentDoc: DocumentNode<GmTimerFieldsFragment, unknown>;
export declare const GmSessionFieldsFragmentDoc: DocumentNode<GmSessionFieldsFragment, unknown>;
export declare const GmContainerFieldsFragmentDoc: DocumentNode<GmContainerFieldsFragment, unknown>;
export declare const GmInvokeResultFieldsFragmentDoc: DocumentNode<GmInvokeResultFieldsFragment, unknown>;
export declare const GmFunctionFieldsFragmentDoc: DocumentNode<GmFunctionFieldsFragment, unknown>;
export declare const GmPropertyDefFieldsFragmentDoc: DocumentNode<GmPropertyDefFieldsFragment, unknown>;
export declare const PlayerCodeListingFieldsFragmentDoc: DocumentNode<PlayerCodeListingFieldsFragment, unknown>;
export declare const PlayerCodeListingVersionFieldsFragmentDoc: DocumentNode<PlayerCodeListingVersionFieldsFragment, unknown>;
export declare const PlayerCodeAcquisitionFieldsFragmentDoc: DocumentNode<PlayerCodeAcquisitionFieldsFragment, unknown>;
export declare const PlayerCodeInstallFieldsFragmentDoc: DocumentNode<PlayerCodeInstallFieldsFragment, unknown>;
export declare const GridClaimRequestFieldsFragmentDoc: DocumentNode<GridClaimRequestFieldsFragment, unknown>;
export declare const PlayerWasmModuleFieldsFragmentDoc: DocumentNode<PlayerWasmModuleFieldsFragment, unknown>;
export declare const PlayerWasmModuleVersionFieldsFragmentDoc: DocumentNode<PlayerWasmModuleVersionFieldsFragment, unknown>;
export declare const PlayerWasmModuleRunFieldsFragmentDoc: DocumentNode<PlayerWasmModuleRunFieldsFragment, unknown>;
export declare const PlayerWalletFieldsFragmentDoc: DocumentNode<PlayerWalletFieldsFragment, unknown>;
export declare const PlayerWalletTransactionFieldsFragmentDoc: DocumentNode<PlayerWalletTransactionFieldsFragment, unknown>;
export declare const PlayerSpendCapFieldsFragmentDoc: DocumentNode<PlayerSpendCapFieldsFragment, unknown>;
export declare const PlayerAutoBillingFieldsFragmentDoc: DocumentNode<PlayerAutoBillingFieldsFragment, unknown>;
export declare const PlayerUsageChargeFieldsFragmentDoc: DocumentNode<PlayerUsageChargeFieldsFragment, unknown>;
export declare const PlayerWasmPolicyFieldsFragmentDoc: DocumentNode<PlayerWasmPolicyFieldsFragment, unknown>;
export declare const ActorDocument: DocumentNode<ActorQuery, ActorQueryVariables>;
export declare const ActorsDocument: DocumentNode<ActorsQuery, ActorsQueryVariables>;
export declare const ActorsConnectionDocument: DocumentNode<ActorsConnectionQuery, ActorsConnectionQueryVariables>;
export declare const BatchLookupActorsDocument: DocumentNode<BatchLookupActorsQuery, BatchLookupActorsQueryVariables>;
export declare const CreateActorDocument: DocumentNode<CreateActorMutation, CreateActorMutationVariables>;
export declare const DeleteActorDocument: DocumentNode<DeleteActorMutation, DeleteActorMutationVariables>;
export declare const UpdateActorDocument: DocumentNode<UpdateActorMutation, UpdateActorMutationVariables>;
export declare const UpdateActorStateDocument: DocumentNode<UpdateActorStateMutation, UpdateActorStateMutationVariables>;
export declare const AppAccessTiersDocument: DocumentNode<AppAccessTiersQuery, AppAccessTiersQueryVariables>;
export declare const AppGrantMemberCandidatesDocument: DocumentNode<AppGrantMemberCandidatesQuery, AppGrantMemberCandidatesQueryVariables>;
export declare const AppUserAccessByAppDocument: DocumentNode<AppUserAccessByAppQuery, AppUserAccessByAppQueryVariables>;
export declare const AppUserAccessConnectionDocument: DocumentNode<AppUserAccessConnectionQuery, AppUserAccessConnectionQueryVariables>;
export declare const ArchiveAccessTierDocument: DocumentNode<ArchiveAccessTierMutation, ArchiveAccessTierMutationVariables>;
export declare const ClaimFreeAppAccessDocument: DocumentNode<ClaimFreeAppAccessMutation, ClaimFreeAppAccessMutationVariables>;
export declare const CreateAccessTierDocument: DocumentNode<CreateAccessTierMutation, CreateAccessTierMutationVariables>;
export declare const GrantAppAccessDocument: DocumentNode<GrantAppAccessMutation, GrantAppAccessMutationVariables>;
export declare const GrantMyAppAccessDocument: DocumentNode<GrantMyAppAccessMutation, GrantMyAppAccessMutationVariables>;
export declare const MyAppAccessDocument: DocumentNode<MyAppAccessQuery, MyAppAccessQueryVariables>;
export declare const RevokeAppAccessDocument: DocumentNode<RevokeAppAccessMutation, RevokeAppAccessMutationVariables>;
export declare const RuntimePermissionsDocument: DocumentNode<RuntimePermissionsQuery, RuntimePermissionsQueryVariables>;
export declare const UpdateAccessTierDocument: DocumentNode<UpdateAccessTierMutation, UpdateAccessTierMutationVariables>;
export declare const AppDocument: DocumentNode<AppQuery, AppQueryVariables>;
export declare const AppBySlugDocument: DocumentNode<AppBySlugQuery, AppBySlugQueryVariables>;
export declare const AppDiscoveryDocument: DocumentNode<AppDiscoveryQuery, AppDiscoveryQueryVariables>;
export declare const AppsForOrgDocument: DocumentNode<AppsForOrgQuery, AppsForOrgQueryVariables>;
export declare const ArchiveAppDocument: DocumentNode<ArchiveAppMutation, ArchiveAppMutationVariables>;
export declare const AppCodeAdmissionModeDocument: DocumentNode<AppCodeAdmissionModeQuery, AppCodeAdmissionModeQueryVariables>;
export declare const AppCodeAdmissionsDocument: DocumentNode<AppCodeAdmissionsQuery, AppCodeAdmissionsQueryVariables>;
export declare const SetAppCodeAdmissionModeDocument: DocumentNode<SetAppCodeAdmissionModeMutation, SetAppCodeAdmissionModeMutationVariables>;
export declare const AdmitAppCodeDocument: DocumentNode<AdmitAppCodeMutation, AdmitAppCodeMutationVariables>;
export declare const RevokeAppCodeAdmissionDocument: DocumentNode<RevokeAppCodeAdmissionMutation, RevokeAppCodeAdmissionMutationVariables>;
export declare const CreateAppDocument: DocumentNode<CreateAppMutation, CreateAppMutationVariables>;
export declare const MarketplaceAppsDocument: DocumentNode<MarketplaceAppsQuery, MarketplaceAppsQueryVariables>;
export declare const AppsConnectionDocument: DocumentNode<AppsConnectionQuery, AppsConnectionQueryVariables>;
export declare const MyAppsDocument: DocumentNode<MyAppsQuery, MyAppsQueryVariables>;
export declare const PlaceableDatacentersDocument: DocumentNode<PlaceableDatacentersQuery, PlaceableDatacentersQueryVariables>;
export declare const SetAppVisibilityDocument: DocumentNode<SetAppVisibilityMutation, SetAppVisibilityMutationVariables>;
export declare const UpdateAppDocument: DocumentNode<UpdateAppMutation, UpdateAppMutationVariables>;
export declare const LogoutDocument: DocumentNode<LogoutMutation, LogoutMutationVariables>;
export declare const LogoutAllDevicesDocument: DocumentNode<LogoutAllDevicesMutation, LogoutAllDevicesMutationVariables>;
export declare const UserAvatarsDocument: DocumentNode<UserAvatarsQuery, UserAvatarsQueryVariables>;
export declare const AvatarByIdDocument: DocumentNode<AvatarByIdQuery, AvatarByIdQueryVariables>;
export declare const MyAvatarsDocument: DocumentNode<MyAvatarsQuery, MyAvatarsQueryVariables>;
export declare const AvatarAppStateDocument: DocumentNode<AvatarAppStateQuery, AvatarAppStateQueryVariables>;
export declare const AvatarAppStatesDocument: DocumentNode<AvatarAppStatesQuery, AvatarAppStatesQueryVariables>;
export declare const CreateAvatarDocument: DocumentNode<CreateAvatarMutation, CreateAvatarMutationVariables>;
export declare const UpdateAvatarDocument: DocumentNode<UpdateAvatarMutation, UpdateAvatarMutationVariables>;
export declare const DeleteAvatarDocument: DocumentNode<DeleteAvatarMutation, DeleteAvatarMutationVariables>;
export declare const UpdateAvatarStateDocument: DocumentNode<UpdateAvatarStateMutation, UpdateAvatarStateMutationVariables>;
export declare const UpdateAvatarAppStateDocument: DocumentNode<UpdateAvatarAppStateMutation, UpdateAvatarAppStateMutationVariables>;
export declare const AppBudgetDocument: DocumentNode<AppBudgetQuery, AppBudgetQueryVariables>;
export declare const AppBudgetsDocument: DocumentNode<AppBudgetsQuery, AppBudgetsQueryVariables>;
export declare const SetAppBudgetDocument: DocumentNode<SetAppBudgetMutation, SetAppBudgetMutationVariables>;
export declare const WalletBalanceDocument: DocumentNode<WalletBalanceQuery, WalletBalanceQueryVariables>;
export declare const WalletTransactionsDocument: DocumentNode<WalletTransactionsQuery, WalletTransactionsQueryVariables>;
export declare const WalletTransactionsConnectionDocument: DocumentNode<WalletTransactionsConnectionQuery, WalletTransactionsConnectionQueryVariables>;
export declare const AddChannelMemberDocument: DocumentNode<AddChannelMemberMutation, AddChannelMemberMutationVariables>;
export declare const ChannelDocument: DocumentNode<ChannelQuery, ChannelQueryVariables>;
export declare const ChannelMembersDocument: DocumentNode<ChannelMembersQuery, ChannelMembersQueryVariables>;
export declare const ChannelPolicyDocument: DocumentNode<ChannelPolicyQuery, ChannelPolicyQueryVariables>;
export declare const ChannelRolesDocument: DocumentNode<ChannelRolesQuery, ChannelRolesQueryVariables>;
export declare const ChannelsDocument: DocumentNode<ChannelsQuery, ChannelsQueryVariables>;
export declare const CreateChannelDocument: DocumentNode<CreateChannelMutation, CreateChannelMutationVariables>;
export declare const CreateChannelRoleDocument: DocumentNode<CreateChannelRoleMutation, CreateChannelRoleMutationVariables>;
export declare const DeleteChannelDocument: DocumentNode<DeleteChannelMutation, DeleteChannelMutationVariables>;
export declare const DeleteChannelRoleDocument: DocumentNode<DeleteChannelRoleMutation, DeleteChannelRoleMutationVariables>;
export declare const JoinChannelDocument: DocumentNode<JoinChannelMutation, JoinChannelMutationVariables>;
export declare const LeaveChannelDocument: DocumentNode<LeaveChannelMutation, LeaveChannelMutationVariables>;
export declare const MyChannelsDocument: DocumentNode<MyChannelsQuery, MyChannelsQueryVariables>;
export declare const RemoveChannelMemberDocument: DocumentNode<RemoveChannelMemberMutation, RemoveChannelMemberMutationVariables>;
export declare const RequestToJoinChannelDocument: DocumentNode<RequestToJoinChannelMutation, RequestToJoinChannelMutationVariables>;
export declare const SetChannelMemberRolesDocument: DocumentNode<SetChannelMemberRolesMutation, SetChannelMemberRolesMutationVariables>;
export declare const SetChannelPolicyDocument: DocumentNode<SetChannelPolicyMutation, SetChannelPolicyMutationVariables>;
export declare const UpdateChannelDocument: DocumentNode<UpdateChannelMutation, UpdateChannelMutationVariables>;
export declare const UpdateChannelRoleDocument: DocumentNode<UpdateChannelRoleMutation, UpdateChannelRoleMutationVariables>;
export declare const GetChunkDocument: DocumentNode<GetChunkQuery, GetChunkQueryVariables>;
export declare const GetChunkLodsDocument: DocumentNode<GetChunkLodsQuery, GetChunkLodsQueryVariables>;
export declare const GetChunksByDistanceDocument: DocumentNode<GetChunksByDistanceQuery, GetChunksByDistanceQueryVariables>;
export declare const GetVoxelListDocument: DocumentNode<GetVoxelListQuery, GetVoxelListQueryVariables>;
export declare const UpdateChunkDocument: DocumentNode<UpdateChunkMutation, UpdateChunkMutationVariables>;
export declare const UpdateChunkLodsDocument: DocumentNode<UpdateChunkLodsMutation, UpdateChunkLodsMutationVariables>;
export declare const UpdateChunkStateDocument: DocumentNode<UpdateChunkStateMutation, UpdateChunkStateMutationVariables>;
export declare const ComputeUpsertModuleDocument: DocumentNode<ComputeUpsertModuleMutation, ComputeUpsertModuleMutationVariables>;
export declare const ComputeDeployVersionDocument: DocumentNode<ComputeDeployVersionMutation, ComputeDeployVersionMutationVariables>;
export declare const ComputeSetModuleEnabledDocument: DocumentNode<ComputeSetModuleEnabledMutation, ComputeSetModuleEnabledMutationVariables>;
export declare const ComputeResetBreakerDocument: DocumentNode<ComputeResetBreakerMutation, ComputeResetBreakerMutationVariables>;
export declare const ComputeDeleteModuleDocument: DocumentNode<ComputeDeleteModuleMutation, ComputeDeleteModuleMutationVariables>;
export declare const ComputeUpsertTriggerDocument: DocumentNode<ComputeUpsertTriggerMutation, ComputeUpsertTriggerMutationVariables>;
export declare const ComputeDeleteTriggerDocument: DocumentNode<ComputeDeleteTriggerMutation, ComputeDeleteTriggerMutationVariables>;
export declare const ComputeSetPolicyDocument: DocumentNode<ComputeSetPolicyMutation, ComputeSetPolicyMutationVariables>;
export declare const ComputeInvokeDocument: DocumentNode<ComputeInvokeMutation, ComputeInvokeMutationVariables>;
export declare const ComputeModulesDocument: DocumentNode<ComputeModulesQuery, ComputeModulesQueryVariables>;
export declare const ComputeModuleDocument: DocumentNode<ComputeModuleQuery, ComputeModuleQueryVariables>;
export declare const ComputeModuleVersionsDocument: DocumentNode<ComputeModuleVersionsQuery, ComputeModuleVersionsQueryVariables>;
export declare const ComputeModuleTriggersDocument: DocumentNode<ComputeModuleTriggersQuery, ComputeModuleTriggersQueryVariables>;
export declare const ComputeModulePolicyDocument: DocumentNode<ComputeModulePolicyQuery, ComputeModulePolicyQueryVariables>;
export declare const ComputeModuleRunsDocument: DocumentNode<ComputeModuleRunsQuery, ComputeModuleRunsQueryVariables>;
export declare const ComputeModuleStatsDocument: DocumentNode<ComputeModuleStatsQuery, ComputeModuleStatsQueryVariables>;
export declare const ComputeModuleLogsDocument: DocumentNode<ComputeModuleLogsQuery, ComputeModuleLogsQueryVariables>;
export declare const ComputeAppDiagnosticsDocument: DocumentNode<ComputeAppDiagnosticsQuery, ComputeAppDiagnosticsQueryVariables>;
export declare const ComputeTemplatesDocument: DocumentNode<ComputeTemplatesQuery, ComputeTemplatesQueryVariables>;
export declare const ComputeDeployTemplateDocument: DocumentNode<ComputeDeployTemplateMutation, ComputeDeployTemplateMutationVariables>;
export declare const CpComputePlatformCeilingsDocument: DocumentNode<CpComputePlatformCeilingsQuery, CpComputePlatformCeilingsQueryVariables>;
export declare const CpSetComputePlatformCeilingsDocument: DocumentNode<CpSetComputePlatformCeilingsMutation, CpSetComputePlatformCeilingsMutationVariables>;
export declare const CrowdyStudioProjectsDocument: DocumentNode<CrowdyStudioProjectsQuery, CrowdyStudioProjectsQueryVariables>;
export declare const CrowdyStudioProjectDocument: DocumentNode<CrowdyStudioProjectQuery, CrowdyStudioProjectQueryVariables>;
export declare const CrowdyStudioProjectCreateDocument: DocumentNode<CrowdyStudioProjectCreateMutation, CrowdyStudioProjectCreateMutationVariables>;
export declare const CrowdyStudioProjectSaveDocument: DocumentNode<CrowdyStudioProjectSaveMutation, CrowdyStudioProjectSaveMutationVariables>;
export declare const CrowdyStudioLibraryFilesDocument: DocumentNode<CrowdyStudioLibraryFilesQuery, CrowdyStudioLibraryFilesQueryVariables>;
export declare const CrowdyStudioLibrarySaveDocument: DocumentNode<CrowdyStudioLibrarySaveMutation, CrowdyStudioLibrarySaveMutationVariables>;
export declare const CrowdyStudioCommonFilesDocument: DocumentNode<CrowdyStudioCommonFilesQuery, CrowdyStudioCommonFilesQueryVariables>;
export declare const CrowdyStudioProjectImportFileDocument: DocumentNode<CrowdyStudioProjectImportFileMutation, CrowdyStudioProjectImportFileMutationVariables>;
export declare const CrowdyStudioAgentSessionDocument: DocumentNode<CrowdyStudioAgentSessionQuery, CrowdyStudioAgentSessionQueryVariables>;
export declare const CrowdyStudioAgentSessionsDocument: DocumentNode<CrowdyStudioAgentSessionsQuery, CrowdyStudioAgentSessionsQueryVariables>;
export declare const CrowdyStudioAgentHistoryDocument: DocumentNode<CrowdyStudioAgentHistoryQuery, CrowdyStudioAgentHistoryQueryVariables>;
export declare const CrowdyStudioAgentToolDescriptorsDocument: DocumentNode<CrowdyStudioAgentToolDescriptorsQuery, CrowdyStudioAgentToolDescriptorsQueryVariables>;
export declare const CrowdyStudioAgentBudgetDocument: DocumentNode<CrowdyStudioAgentBudgetQuery, CrowdyStudioAgentBudgetQueryVariables>;
export declare const CrowdyStudioAgentCreateSessionDocument: DocumentNode<CrowdyStudioAgentCreateSessionMutation, CrowdyStudioAgentCreateSessionMutationVariables>;
export declare const CrowdyStudioAgentAttachClientDocument: DocumentNode<CrowdyStudioAgentAttachClientMutation, CrowdyStudioAgentAttachClientMutationVariables>;
export declare const CrowdyStudioAgentSetModeDocument: DocumentNode<CrowdyStudioAgentSetModeMutation, CrowdyStudioAgentSetModeMutationVariables>;
export declare const CrowdyStudioAgentAcknowledgeEventsDocument: DocumentNode<CrowdyStudioAgentAcknowledgeEventsMutation, CrowdyStudioAgentAcknowledgeEventsMutationVariables>;
export declare const CrowdyStudioAgentHeartbeatDocument: DocumentNode<CrowdyStudioAgentHeartbeatMutation, CrowdyStudioAgentHeartbeatMutationVariables>;
export declare const CrowdyStudioAgentSendMessageDocument: DocumentNode<CrowdyStudioAgentSendMessageMutation, CrowdyStudioAgentSendMessageMutationVariables>;
export declare const CrowdyStudioAgentApproveToolDocument: DocumentNode<CrowdyStudioAgentApproveToolMutation, CrowdyStudioAgentApproveToolMutationVariables>;
export declare const CrowdyStudioAgentRejectToolDocument: DocumentNode<CrowdyStudioAgentRejectToolMutation, CrowdyStudioAgentRejectToolMutationVariables>;
export declare const CrowdyStudioAgentToolResultDocument: DocumentNode<CrowdyStudioAgentToolResultMutation, CrowdyStudioAgentToolResultMutationVariables>;
export declare const CrowdyStudioAgentGrantLeaseDocument: DocumentNode<CrowdyStudioAgentGrantLeaseMutation, CrowdyStudioAgentGrantLeaseMutationVariables>;
export declare const CrowdyStudioAgentRevokeLeaseDocument: DocumentNode<CrowdyStudioAgentRevokeLeaseMutation, CrowdyStudioAgentRevokeLeaseMutationVariables>;
export declare const CrowdyStudioAgentPauseDocument: DocumentNode<CrowdyStudioAgentPauseMutation, CrowdyStudioAgentPauseMutationVariables>;
export declare const CrowdyStudioAgentResumeDocument: DocumentNode<CrowdyStudioAgentResumeMutation, CrowdyStudioAgentResumeMutationVariables>;
export declare const CrowdyStudioAgentCancelRunDocument: DocumentNode<CrowdyStudioAgentCancelRunMutation, CrowdyStudioAgentCancelRunMutationVariables>;
export declare const CrowdyStudioAgentCloseSessionDocument: DocumentNode<CrowdyStudioAgentCloseSessionMutation, CrowdyStudioAgentCloseSessionMutationVariables>;
export declare const CrowdyStudioAgentEventsDocument: DocumentNode<CrowdyStudioAgentEventsSubscription, CrowdyStudioAgentEventsSubscriptionVariables>;
export declare const GridOwnershipDocument: DocumentNode<GridOwnershipQuery, GridOwnershipQueryVariables>;
export declare const AssignGridOwnershipDocument: DocumentNode<AssignGridOwnershipMutation, AssignGridOwnershipMutationVariables>;
export declare const TransferGridOwnershipDocument: DocumentNode<TransferGridOwnershipMutation, TransferGridOwnershipMutationVariables>;
export declare const GridUserPermissionsDocument: DocumentNode<GridUserPermissionsQuery, GridUserPermissionsQueryVariables>;
export declare const NearbyGridPermissionsDocument: DocumentNode<NearbyGridPermissionsQuery, NearbyGridPermissionsQueryVariables>;
export declare const GridPermissionLimitsDocument: DocumentNode<GridPermissionLimitsQuery, GridPermissionLimitsQueryVariables>;
export declare const GridGroupGrantsDocument: DocumentNode<GridGroupGrantsQuery, GridGroupGrantsQueryVariables>;
export declare const CreateGridDocument: DocumentNode<CreateGridMutation, CreateGridMutationVariables>;
export declare const DeleteGridDocument: DocumentNode<DeleteGridMutation, DeleteGridMutationVariables>;
export declare const GrantGridPermissionsDocument: DocumentNode<GrantGridPermissionsMutation, GrantGridPermissionsMutationVariables>;
export declare const RevokeGridPermissionsDocument: DocumentNode<RevokeGridPermissionsMutation, RevokeGridPermissionsMutationVariables>;
export declare const SetGridPermissionLimitsDocument: DocumentNode<SetGridPermissionLimitsMutation, SetGridPermissionLimitsMutationVariables>;
export declare const AssignGroupToGridDocument: DocumentNode<AssignGroupToGridMutation, AssignGroupToGridMutationVariables>;
export declare const RevokeGroupFromGridDocument: DocumentNode<RevokeGroupFromGridMutation, RevokeGroupFromGridMutationVariables>;
export declare const GameModelUpsertAutomationDocument: DocumentNode<GameModelUpsertAutomationMutation, GameModelUpsertAutomationMutationVariables>;
export declare const GameModelDeleteAutomationDocument: DocumentNode<GameModelDeleteAutomationMutation, GameModelDeleteAutomationMutationVariables>;
export declare const GameModelSetAutomationEnabledDocument: DocumentNode<GameModelSetAutomationEnabledMutation, GameModelSetAutomationEnabledMutationVariables>;
export declare const GameModelUpsertAutomationTriggerDocument: DocumentNode<GameModelUpsertAutomationTriggerMutation, GameModelUpsertAutomationTriggerMutationVariables>;
export declare const GameModelDeleteAutomationTriggerDocument: DocumentNode<GameModelDeleteAutomationTriggerMutation, GameModelDeleteAutomationTriggerMutationVariables>;
export declare const GameModelSetAutomationPolicyDocument: DocumentNode<GameModelSetAutomationPolicyMutation, GameModelSetAutomationPolicyMutationVariables>;
export declare const GameModelRunAutomationDocument: DocumentNode<GameModelRunAutomationMutation, GameModelRunAutomationMutationVariables>;
export declare const GameModelAutomationsDocument: DocumentNode<GameModelAutomationsQuery, GameModelAutomationsQueryVariables>;
export declare const GameModelAutomationDocument: DocumentNode<GameModelAutomationQuery, GameModelAutomationQueryVariables>;
export declare const GameModelAutomationTriggersDocument: DocumentNode<GameModelAutomationTriggersQuery, GameModelAutomationTriggersQueryVariables>;
export declare const GameModelAutomationPolicyDocument: DocumentNode<GameModelAutomationPolicyQuery, GameModelAutomationPolicyQueryVariables>;
export declare const GameModelAutomationRunsDocument: DocumentNode<GameModelAutomationRunsQuery, GameModelAutomationRunsQueryVariables>;
export declare const GameModelAutomationStatsDocument: DocumentNode<GameModelAutomationStatsQuery, GameModelAutomationStatsQueryVariables>;
export declare const GameModelAppDiagnosticsDocument: DocumentNode<GameModelAppDiagnosticsQuery, GameModelAppDiagnosticsQueryVariables>;
export declare const GameModelScheduleInvokeDocument: DocumentNode<GameModelScheduleInvokeMutation, GameModelScheduleInvokeMutationVariables>;
export declare const GameModelCancelTimerDocument: DocumentNode<GameModelCancelTimerMutation, GameModelCancelTimerMutationVariables>;
export declare const GameModelTimersDocument: DocumentNode<GameModelTimersQuery, GameModelTimersQueryVariables>;
export declare const GameModelActivePlayerCountDocument: DocumentNode<GameModelActivePlayerCountQuery, GameModelActivePlayerCountQueryVariables>;
export declare const GameModelActivePlayerCountChangedDocument: DocumentNode<GameModelActivePlayerCountChangedSubscription, GameModelActivePlayerCountChangedSubscriptionVariables>;
export declare const GameModelCreateSessionDocument: DocumentNode<GameModelCreateSessionMutation, GameModelCreateSessionMutationVariables>;
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>;
export declare const GameModelContainerChangedDocument: DocumentNode<GameModelContainerChangedSubscription, GameModelContainerChangedSubscriptionVariables>;
export declare const GameModelContainerStateDocument: DocumentNode<GameModelContainerStateQuery, GameModelContainerStateQueryVariables>;
export declare const GameModelTraverseDocument: DocumentNode<GameModelTraverseQuery, GameModelTraverseQueryVariables>;
export declare const GameModelSessionDocument: DocumentNode<GameModelSessionQuery, GameModelSessionQueryVariables>;
export declare const GameModelSessionsDocument: DocumentNode<GameModelSessionsQuery, GameModelSessionsQueryVariables>;
export declare const GameModelEventsDocument: DocumentNode<GameModelEventsQuery, GameModelEventsQueryVariables>;
export declare const GameModelEventsConnectionDocument: DocumentNode<GameModelEventsConnectionQuery, GameModelEventsConnectionQueryVariables>;
export declare const GameModelFlowDocument: DocumentNode<GameModelFlowQuery, GameModelFlowQueryVariables>;
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>;
export declare const GameModelGrantTierFeatureDocument: DocumentNode<GameModelGrantTierFeatureMutation, GameModelGrantTierFeatureMutationVariables>;
export declare const GameModelSetPolicyDocument: DocumentNode<GameModelSetPolicyMutation, GameModelSetPolicyMutationVariables>;
export declare const GameModelTypeSchemaDocument: DocumentNode<GameModelTypeSchemaQuery, GameModelTypeSchemaQueryVariables>;
export declare const GameModelContainerTypesDocument: DocumentNode<GameModelContainerTypesQuery, GameModelContainerTypesQueryVariables>;
export declare const GameModelPropertyDefsDocument: DocumentNode<GameModelPropertyDefsQuery, GameModelPropertyDefsQueryVariables>;
export declare const GameModelFunctionDocument: DocumentNode<GameModelFunctionQuery, GameModelFunctionQueryVariables>;
export declare const GameModelFunctionsDocument: DocumentNode<GameModelFunctionsQuery, GameModelFunctionsQueryVariables>;
export declare const GameModelFeaturesDocument: DocumentNode<GameModelFeaturesQuery, GameModelFeaturesQueryVariables>;
export declare const GameModelTierFeaturesDocument: DocumentNode<GameModelTierFeaturesQuery, GameModelTierFeaturesQueryVariables>;
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 MarketplaceListingsDocument: DocumentNode<MarketplaceListingsQuery, MarketplaceListingsQueryVariables>;
export declare const MarketplaceListingVersionsDocument: DocumentNode<MarketplaceListingVersionsQuery, MarketplaceListingVersionsQueryVariables>;
export declare const MarketplaceMyAcquisitionsDocument: DocumentNode<MarketplaceMyAcquisitionsQuery, MarketplaceMyAcquisitionsQueryVariables>;
export declare const MarketplaceMyInstallsDocument: DocumentNode<MarketplaceMyInstallsQuery, MarketplaceMyInstallsQueryVariables>;
export declare const MarketplaceGridClientModsDocument: DocumentNode<MarketplaceGridClientModsQuery, MarketplaceGridClientModsQueryVariables>;
export declare const MarketplaceClientArtifactDocument: DocumentNode<MarketplaceClientArtifactQuery, MarketplaceClientArtifactQueryVariables>;
export declare const MarketplaceTrustGridAuthorDocument: DocumentNode<MarketplaceTrustGridAuthorMutation, MarketplaceTrustGridAuthorMutationVariables>;
export declare const MarketplacePublishListingDocument: DocumentNode<MarketplacePublishListingMutation, MarketplacePublishListingMutationVariables>;
export declare const MarketplacePublishVersionDocument: DocumentNode<MarketplacePublishVersionMutation, MarketplacePublishVersionMutationVariables>;
export declare const MarketplaceAcquireDocument: DocumentNode<MarketplaceAcquireMutation, MarketplaceAcquireMutationVariables>;
export declare const MarketplaceInstallDocument: DocumentNode<MarketplaceInstallMutation, MarketplaceInstallMutationVariables>;
export declare const MarketplaceUninstallDocument: DocumentNode<MarketplaceUninstallMutation, MarketplaceUninstallMutationVariables>;
export declare const MarketplaceConsentGridClientModDocument: DocumentNode<MarketplaceConsentGridClientModMutation, MarketplaceConsentGridClientModMutationVariables>;
export declare const MarketplaceGridClaimPolicyDocument: DocumentNode<MarketplaceGridClaimPolicyQuery, MarketplaceGridClaimPolicyQueryVariables>;
export declare const MarketplaceGridClaimRequestsDocument: DocumentNode<MarketplaceGridClaimRequestsQuery, MarketplaceGridClaimRequestsQueryVariables>;
export declare const MarketplaceClaimGridOwnershipDocument: DocumentNode<MarketplaceClaimGridOwnershipMutation, MarketplaceClaimGridOwnershipMutationVariables>;
export declare const MarketplaceClaimGridChunkDocument: DocumentNode<MarketplaceClaimGridChunkMutation, MarketplaceClaimGridChunkMutationVariables>;
export declare const MarketplaceReleaseClaimedGridDocument: DocumentNode<MarketplaceReleaseClaimedGridMutation, MarketplaceReleaseClaimedGridMutationVariables>;
export declare const MarketplaceDecideGridClaimDocument: DocumentNode<MarketplaceDecideGridClaimMutation, MarketplaceDecideGridClaimMutationVariables>;
export declare const MarketplaceIssueGridClaimInviteDocument: DocumentNode<MarketplaceIssueGridClaimInviteMutation, MarketplaceIssueGridClaimInviteMutationVariables>;
export declare const MarketplaceAdmissionQueueDocument: DocumentNode<MarketplaceAdmissionQueueQuery, MarketplaceAdmissionQueueQueryVariables>;
export declare const MarketplaceAppListingsDocument: DocumentNode<MarketplaceAppListingsQuery, MarketplaceAppListingsQueryVariables>;
export declare const MarketplaceAppAcquisitionsDocument: DocumentNode<MarketplaceAppAcquisitionsQuery, MarketplaceAppAcquisitionsQueryVariables>;
export declare const MarketplaceTransferListingDocument: DocumentNode<MarketplaceTransferListingMutation, MarketplaceTransferListingMutationVariables>;
export declare const MarketplaceSetListingStatusDocument: DocumentNode<MarketplaceSetListingStatusMutation, MarketplaceSetListingStatusMutationVariables>;
export declare const MarketplaceSetGridClaimPolicyDocument: DocumentNode<MarketplaceSetGridClaimPolicyMutation, MarketplaceSetGridClaimPolicyMutationVariables>;
export declare const MarketplaceRenewAcquisitionDocument: DocumentNode<MarketplaceRenewAcquisitionMutation, MarketplaceRenewAcquisitionMutationVariables>;
export declare const MarketplaceTopUpAcquisitionDocument: DocumentNode<MarketplaceTopUpAcquisitionMutation, MarketplaceTopUpAcquisitionMutationVariables>;
export declare const MarketplaceRefundAcquisitionDocument: DocumentNode<MarketplaceRefundAcquisitionMutation, MarketplaceRefundAcquisitionMutationVariables>;
export declare const MarketplaceGridListingsDocument: DocumentNode<MarketplaceGridListingsQuery, MarketplaceGridListingsQueryVariables>;
export declare const MarketplacePurchaseGridDocument: DocumentNode<MarketplacePurchaseGridMutation, MarketplacePurchaseGridMutationVariables>;
export declare const MarketplaceSetListingPricingDocument: DocumentNode<MarketplaceSetListingPricingMutation, MarketplaceSetListingPricingMutationVariables>;
export declare const MarketplaceSetOrgShareDocument: DocumentNode<MarketplaceSetOrgShareMutation, MarketplaceSetOrgShareMutationVariables>;
export declare const MarketplaceBeginSellerOnboardingDocument: DocumentNode<MarketplaceBeginSellerOnboardingMutation, MarketplaceBeginSellerOnboardingMutationVariables>;
export declare const MarketplaceCreateAccountSessionDocument: DocumentNode<MarketplaceCreateAccountSessionMutation, MarketplaceCreateAccountSessionMutationVariables>;
export declare const MarketplaceCreateOrgAccountSessionDocument: DocumentNode<MarketplaceCreateOrgAccountSessionMutation, MarketplaceCreateOrgAccountSessionMutationVariables>;
export declare const MarketplaceBeginOrgSellerOnboardingDocument: DocumentNode<MarketplaceBeginOrgSellerOnboardingMutation, MarketplaceBeginOrgSellerOnboardingMutationVariables>;
export declare const MarketplaceMySellerBalanceDocument: DocumentNode<MarketplaceMySellerBalanceQuery, MarketplaceMySellerBalanceQueryVariables>;
export declare const MarketplaceRequestPayoutDocument: DocumentNode<MarketplaceRequestPayoutMutation, MarketplaceRequestPayoutMutationVariables>;
export declare const MarketplaceSpendPayoutToWalletDocument: DocumentNode<MarketplaceSpendPayoutToWalletMutation, MarketplaceSpendPayoutToWalletMutationVariables>;
export declare const MarketplaceCommerceRiskQueueDocument: DocumentNode<MarketplaceCommerceRiskQueueQuery, MarketplaceCommerceRiskQueueQueryVariables>;
export declare const MarketplaceDecideRiskFlagDocument: DocumentNode<MarketplaceDecideRiskFlagMutation, MarketplaceDecideRiskFlagMutationVariables>;
export declare const MarketplaceCreateGridListingDocument: DocumentNode<MarketplaceCreateGridListingMutation, MarketplaceCreateGridListingMutationVariables>;
export declare const CreateOrgRoleDocument: DocumentNode<CreateOrgRoleMutation, CreateOrgRoleMutationVariables>;
export declare const CreateOrgTokenDocument: DocumentNode<CreateOrgTokenMutation, CreateOrgTokenMutationVariables>;
export declare const CreateOrganizationDocument: DocumentNode<CreateOrganizationMutation, CreateOrganizationMutationVariables>;
export declare const DeleteOrgRoleDocument: DocumentNode<DeleteOrgRoleMutation, DeleteOrgRoleMutationVariables>;
export declare const InviteOrgMemberDocument: DocumentNode<InviteOrgMemberMutation, InviteOrgMemberMutationVariables>;
export declare const MemberRolesDocument: DocumentNode<MemberRolesQuery, MemberRolesQueryVariables>;
export declare const MyOrganizationsDocument: DocumentNode<MyOrganizationsQuery, MyOrganizationsQueryVariables>;
export declare const OrgMembersDocument: DocumentNode<OrgMembersQuery, OrgMembersQueryVariables>;
export declare const OrgPermissionsDocument: DocumentNode<OrgPermissionsQuery, OrgPermissionsQueryVariables>;
export declare const OrgRolesDocument: DocumentNode<OrgRolesQuery, OrgRolesQueryVariables>;
export declare const OrgTokensDocument: DocumentNode<OrgTokensQuery, OrgTokensQueryVariables>;
export declare const OrganizationDocument: DocumentNode<OrganizationQuery, OrganizationQueryVariables>;
export declare const OrganizationBySlugDocument: DocumentNode<OrganizationBySlugQuery, OrganizationBySlugQueryVariables>;
export declare const RemoveOrgMemberDocument: DocumentNode<RemoveOrgMemberMutation, RemoveOrgMemberMutationVariables>;
export declare const RevokeOrgTokenDocument: DocumentNode<RevokeOrgTokenMutation, RevokeOrgTokenMutationVariables>;
export declare const SetOrgStatusDocument: DocumentNode<SetOrgStatusMutation, SetOrgStatusMutationVariables>;
export declare const UpdateOrgMemberRolesDocument: DocumentNode<UpdateOrgMemberRolesMutation, UpdateOrgMemberRolesMutationVariables>;
export declare const UpdateOrgRoleDocument: DocumentNode<UpdateOrgRoleMutation, UpdateOrgRoleMutationVariables>;
export declare const UpdateOrgTokenDocument: DocumentNode<UpdateOrgTokenMutation, UpdateOrgTokenMutationVariables>;
export declare const CapturePaypalCheckoutDocument: DocumentNode<CapturePaypalCheckoutMutation, CapturePaypalCheckoutMutationVariables>;
export declare const CheckoutsDocument: DocumentNode<CheckoutsQuery, CheckoutsQueryVariables>;
export declare const CheckoutsConnectionDocument: DocumentNode<CheckoutsConnectionQuery, CheckoutsConnectionQueryVariables>;
export declare const CreateCheckoutDocument: DocumentNode<CreateCheckoutMutation, CreateCheckoutMutationVariables>;
export declare const MyCheckoutsDocument: DocumentNode<MyCheckoutsQuery, MyCheckoutsQueryVariables>;
export declare const MyCheckoutsConnectionDocument: DocumentNode<MyCheckoutsConnectionQuery, MyCheckoutsConnectionQueryVariables>;
export declare const PaymentEventsDocument: DocumentNode<PaymentEventsQuery, PaymentEventsQueryVariables>;
export declare const PaymentEventsConnectionDocument: DocumentNode<PaymentEventsConnectionQuery, PaymentEventsConnectionQueryVariables>;
export declare const PlatformConfigDocument: DocumentNode<PlatformConfigQuery, PlatformConfigQueryVariables>;
export declare const PlayerComputeDeployDocument: DocumentNode<PlayerComputeDeployMutation, PlayerComputeDeployMutationVariables>;
export declare const PlayerComputeSetEnabledDocument: DocumentNode<PlayerComputeSetEnabledMutation, PlayerComputeSetEnabledMutationVariables>;
export declare const PlayerComputeSetRequiresDocument: DocumentNode<PlayerComputeSetRequiresMutation, PlayerComputeSetRequiresMutationVariables>;
export declare const PlayerComputeMyModulesDocument: DocumentNode<PlayerComputeMyModulesQuery, PlayerComputeMyModulesQueryVariables>;
export declare const PlayerComputeVersionsDocument: DocumentNode<PlayerComputeVersionsQuery, PlayerComputeVersionsQueryVariables>;
export declare const PlayerComputeDeleteDocument: DocumentNode<PlayerComputeDeleteMutation, PlayerComputeDeleteMutationVariables>;
export declare const PlayerComputeInvokeDocument: DocumentNode<PlayerComputeInvokeMutation, PlayerComputeInvokeMutationVariables>;
export declare const PlayerComputeUsageDocument: DocumentNode<PlayerComputeUsageQuery, PlayerComputeUsageQueryVariables>;
export declare const PlayerComputeRunsDocument: DocumentNode<PlayerComputeRunsQuery, PlayerComputeRunsQueryVariables>;
export declare const PlayerComputeLogsDocument: DocumentNode<PlayerComputeLogsQuery, PlayerComputeLogsQueryVariables>;
export declare const PlayerComputeSetSwitchDocument: DocumentNode<PlayerComputeSetSwitchMutation, PlayerComputeSetSwitchMutationVariables>;
export declare const PlayerComputeSwitchesDocument: DocumentNode<PlayerComputeSwitchesQuery, PlayerComputeSwitchesQueryVariables>;
export declare const PlayerComputeArtifactDocument: DocumentNode<PlayerComputeArtifactQuery, PlayerComputeArtifactQueryVariables>;
export declare const PlayerModelContainersDocument: DocumentNode<PlayerModelContainersQuery, PlayerModelContainersQueryVariables>;
export declare const PlayerModelContainerDocument: DocumentNode<PlayerModelContainerQuery, PlayerModelContainerQueryVariables>;
export declare const PlayerModelCreateContainerDocument: DocumentNode<PlayerModelCreateContainerMutation, PlayerModelCreateContainerMutationVariables>;
export declare const PlayerModelSetPropertyDocument: DocumentNode<PlayerModelSetPropertyMutation, PlayerModelSetPropertyMutationVariables>;
export declare const PlayerModelDeleteContainerDocument: DocumentNode<PlayerModelDeleteContainerMutation, PlayerModelDeleteContainerMutationVariables>;
export declare const PlayerAutomationsDocument: DocumentNode<PlayerAutomationsQuery, PlayerAutomationsQueryVariables>;
export declare const PlayerAutomationCreateDocument: DocumentNode<PlayerAutomationCreateMutation, PlayerAutomationCreateMutationVariables>;
export declare const PlayerAutomationSetEnabledDocument: DocumentNode<PlayerAutomationSetEnabledMutation, PlayerAutomationSetEnabledMutationVariables>;
export declare const PlayerAutomationDeleteDocument: DocumentNode<PlayerAutomationDeleteMutation, PlayerAutomationDeleteMutationVariables>;
export declare const PlayerWalletBalanceDocument: DocumentNode<PlayerWalletBalanceQuery, PlayerWalletBalanceQueryVariables>;
export declare const PlayerWalletTransactionsDocument: DocumentNode<PlayerWalletTransactionsQuery, PlayerWalletTransactionsQueryVariables>;
export declare const PlayerUsageChargesDocument: DocumentNode<PlayerUsageChargesQuery, PlayerUsageChargesQueryVariables>;
export declare const PlayerSpendCapsDocument: DocumentNode<PlayerSpendCapsQuery, PlayerSpendCapsQueryVariables>;
export declare const SetPlayerSpendCapDocument: DocumentNode<SetPlayerSpendCapMutation, SetPlayerSpendCapMutationVariables>;
export declare const PlayerAutoBillingDocument: DocumentNode<PlayerAutoBillingQuery, PlayerAutoBillingQueryVariables>;
export declare const BeginPlayerCardSetupDocument: DocumentNode<BeginPlayerCardSetupMutation, BeginPlayerCardSetupMutationVariables>;
export declare const SetPlayerAutoBillingDocument: DocumentNode<SetPlayerAutoBillingMutation, SetPlayerAutoBillingMutationVariables>;
export declare const PlayerRuntimeStatesDocument: DocumentNode<PlayerRuntimeStatesQuery, PlayerRuntimeStatesQueryVariables>;
export declare const PlayerWasmPoliciesDocument: DocumentNode<PlayerWasmPoliciesQuery, PlayerWasmPoliciesQueryVariables>;
export declare const SetPlayerWasmPolicyDocument: DocumentNode<SetPlayerWasmPolicyMutation, SetPlayerWasmPolicyMutationVariables>;
export declare const DeletePlayerWasmPolicyDocument: DocumentNode<DeletePlayerWasmPolicyMutation, DeletePlayerWasmPolicyMutationVariables>;
export declare const PlayerRateMarkupDocument: DocumentNode<PlayerRateMarkupQuery, PlayerRateMarkupQueryVariables>;
export declare const SetPlayerRateMarkupDocument: DocumentNode<SetPlayerRateMarkupMutation, SetPlayerRateMarkupMutationVariables>;
export declare const AppPlayerUsageDocument: DocumentNode<AppPlayerUsageQuery, AppPlayerUsageQueryVariables>;
export declare const AppPlayerMarkupAccruedDocument: DocumentNode<AppPlayerMarkupAccruedQuery, AppPlayerMarkupAccruedQueryVariables>;
export declare const DeleteQuotaDocument: DocumentNode<DeleteQuotaMutation, DeleteQuotaMutationVariables>;
export declare const EffectiveQuotaDocument: DocumentNode<EffectiveQuotaQuery, EffectiveQuotaQueryVariables>;
export declare const QuotasForAppDocument: DocumentNode<QuotasForAppQuery, QuotasForAppQueryVariables>;
export declare const QuotasForOrgDocument: DocumentNode<QuotasForOrgQuery, QuotasForOrgQueryVariables>;
export declare const SetQuotaDocument: DocumentNode<SetQuotaMutation, SetQuotaMutationVariables>;
export declare const ActiveGraphQlServersDocument: DocumentNode<ActiveGraphQlServersQuery, ActiveGraphQlServersQueryVariables>;
export declare const GameClientBootstrapDocument: DocumentNode<GameClientBootstrapQuery, GameClientBootstrapQueryVariables>;
export declare const GraphqlServersDocument: DocumentNode<GraphqlServersQuery, GraphqlServersQueryVariables>;
export declare const ServerWithLeastClientsDocument: DocumentNode<ServerWithLeastClientsQuery, ServerWithLeastClientsQueryVariables>;
export declare const VersionInfoDocument: DocumentNode<VersionInfoQuery, VersionInfoQueryVariables>;
export declare const SharedEnvPlansDocument: DocumentNode<SharedEnvPlansQuery, SharedEnvPlansQueryVariables>;
export declare const OrgFreeAppQuotaDocument: DocumentNode<OrgFreeAppQuotaQuery, OrgFreeAppQuotaQueryVariables>;
export declare const AppSharedSubscriptionDocument: DocumentNode<AppSharedSubscriptionQuery, AppSharedSubscriptionQueryVariables>;
export declare const AppRuntimeStateDocument: DocumentNode<AppRuntimeStateQuery, AppRuntimeStateQueryVariables>;
export declare const OrgAutoBillingDocument: DocumentNode<OrgAutoBillingQuery, OrgAutoBillingQueryVariables>;
export declare const OrgPaymentMethodsDocument: DocumentNode<OrgPaymentMethodsQuery, OrgPaymentMethodsQueryVariables>;
export declare const PublishAppToSharedDocument: DocumentNode<PublishAppToSharedMutation, PublishAppToSharedMutationVariables>;
export declare const CancelSharedSubscriptionDocument: DocumentNode<CancelSharedSubscriptionMutation, CancelSharedSubscriptionMutationVariables>;
export declare const SetAppSpendCapsDocument: DocumentNode<SetAppSpendCapsMutation, SetAppSpendCapsMutationVariables>;
export declare const SetAutoBillingDocument: DocumentNode<SetAutoBillingMutation, SetAutoBillingMutationVariables>;
export declare const SetupSharedPaymentMethodDocument: DocumentNode<SetupSharedPaymentMethodMutation, SetupSharedPaymentMethodMutationVariables>;
export declare const RemoveSharedPaymentMethodDocument: DocumentNode<RemoveSharedPaymentMethodMutation, RemoveSharedPaymentMethodMutationVariables>;
export declare const DeleteUserAppStateDocument: DocumentNode<DeleteUserAppStateMutation, DeleteUserAppStateMutationVariables>;
export declare const UpdateUserAppStateDocument: DocumentNode<UpdateUserAppStateMutation, UpdateUserAppStateMutationVariables>;
export declare const UserAppStateDocument: DocumentNode<UserAppStateQuery, UserAppStateQueryVariables>;
export declare const UserAppStatesDocument: DocumentNode<UserAppStatesQuery, UserAppStatesQueryVariables>;
export declare const AddTeamMemberDocument: DocumentNode<AddTeamMemberMutation, AddTeamMemberMutationVariables>;
export declare const CreateTeamDocument: DocumentNode<CreateTeamMutation, CreateTeamMutationVariables>;
export declare const CreateTeamRoleDocument: DocumentNode<CreateTeamRoleMutation, CreateTeamRoleMutationVariables>;
export declare const DeleteTeamDocument: DocumentNode<DeleteTeamMutation, DeleteTeamMutationVariables>;
export declare const DeleteTeamRoleDocument: DocumentNode<DeleteTeamRoleMutation, DeleteTeamRoleMutationVariables>;
export declare const JoinTeamDocument: DocumentNode<JoinTeamMutation, JoinTeamMutationVariables>;
export declare const LeaveTeamDocument: DocumentNode<LeaveTeamMutation, LeaveTeamMutationVariables>;
export declare const MyTeamsDocument: DocumentNode<MyTeamsQuery, MyTeamsQueryVariables>;
export declare const RemoveTeamMemberDocument: DocumentNode<RemoveTeamMemberMutation, RemoveTeamMemberMutationVariables>;
export declare const RequestToJoinTeamDocument: DocumentNode<RequestToJoinTeamMutation, RequestToJoinTeamMutationVariables>;
export declare const SetTeamMemberRolesDocument: DocumentNode<SetTeamMemberRolesMutation, SetTeamMemberRolesMutationVariables>;
export declare const SetTeamPolicyDocument: DocumentNode<SetTeamPolicyMutation, SetTeamPolicyMutationVariables>;
export declare const TeamDocument: DocumentNode<TeamQuery, TeamQueryVariables>;
export declare const TeamMembersDocument: DocumentNode<TeamMembersQuery, TeamMembersQueryVariables>;
export declare const TeamPolicyDocument: DocumentNode<TeamPolicyQuery, TeamPolicyQueryVariables>;
export declare const TeamRolesDocument: DocumentNode<TeamRolesQuery, TeamRolesQueryVariables>;
export declare const TeamsDocument: DocumentNode<TeamsQuery, TeamsQueryVariables>;
export declare const UpdateTeamDocument: DocumentNode<UpdateTeamMutation, UpdateTeamMutationVariables>;
export declare const UpdateTeamRoleDocument: DocumentNode<UpdateTeamRoleMutation, UpdateTeamRoleMutationVariables>;
export declare const TeleportRequestDocument: DocumentNode<TeleportRequestMutation, TeleportRequestMutationVariables>;
export declare const ConnectUdpProxyDocument: DocumentNode<ConnectUdpProxyMutation, ConnectUdpProxyMutationVariables>;
export declare const DisconnectUdpProxyDocument: DocumentNode<DisconnectUdpProxyMutation, DisconnectUdpProxyMutationVariables>;
export declare const SendActorUpdateDocument: DocumentNode<SendActorUpdateMutation, SendActorUpdateMutationVariables>;
export declare const SendAudioPacketDocument: DocumentNode<SendAudioPacketMutation, SendAudioPacketMutationVariables>;
export declare const SendChannelMessageDocument: DocumentNode<SendChannelMessageMutation, SendChannelMessageMutationVariables>;
export declare const SendClientEventDocument: DocumentNode<SendClientEventMutation, SendClientEventMutationVariables>;
export declare const SendSingleActorMessageDocument: DocumentNode<SendSingleActorMessageMutation, SendSingleActorMessageMutationVariables>;
export declare const SendTextPacketDocument: DocumentNode<SendTextPacketMutation, SendTextPacketMutationVariables>;
export declare const SendVoxelUpdateDocument: DocumentNode<SendVoxelUpdateMutation, SendVoxelUpdateMutationVariables>;
export declare const UdpNotificationsDocument: DocumentNode<UdpNotificationsSubscription, UdpNotificationsSubscriptionVariables>;
export declare const UdpProxyConnectionStatusDocument: DocumentNode<UdpProxyConnectionStatusQuery, UdpProxyConnectionStatusQueryVariables>;
export declare const AppGraphqlOperationsDocument: DocumentNode<AppGraphqlOperationsQuery, AppGraphqlOperationsQueryVariables>;
export declare const AppUsageSummaryDocument: DocumentNode<AppUsageSummaryQuery, AppUsageSummaryQueryVariables>;
export declare const PlayerPulseDocument: DocumentNode<PlayerPulseQuery, PlayerPulseQueryVariables>;
export declare const DeleteMyAccountDocument: DocumentNode<DeleteMyAccountMutation, DeleteMyAccountMutationVariables>;
export declare const ForceLogoutUserDocument: DocumentNode<ForceLogoutUserMutation, ForceLogoutUserMutationVariables>;
export declare const FreePlayWindowDocument: DocumentNode<FreePlayWindowQuery, FreePlayWindowQueryVariables>;
export declare const MeDocument: DocumentNode<MeQuery, MeQueryVariables>;
export declare const SetEarlyAccessOverrideDocument: DocumentNode<SetEarlyAccessOverrideMutation, SetEarlyAccessOverrideMutationVariables>;
export declare const SetOperatorDocument: DocumentNode<SetOperatorMutation, SetOperatorMutationVariables>;
export declare const SetSuperAdminDocument: DocumentNode<SetSuperAdminMutation, SetSuperAdminMutationVariables>;
export declare const UpdateGamertagDocument: DocumentNode<UpdateGamertagMutation, UpdateGamertagMutationVariables>;
export declare const UpdateUserStateDocument: DocumentNode<UpdateUserStateMutation, UpdateUserStateMutationVariables>;
export declare const UpdateUserTypeDocument: DocumentNode<UpdateUserTypeMutation, UpdateUserTypeMutationVariables>;
export declare const UserDocument: DocumentNode<UserQuery, UserQueryVariables>;
export declare const UsersPaginatedDocument: DocumentNode<UsersPaginatedQuery, UsersPaginatedQueryVariables>;
export declare const UsersConnectionDocument: DocumentNode<UsersConnectionQuery, UsersConnectionQueryVariables>;
export declare const ListVoxelUpdatesByDistanceDocument: DocumentNode<ListVoxelUpdatesByDistanceQuery, ListVoxelUpdatesByDistanceQueryVariables>;
export declare const ListVoxelsDocument: DocumentNode<ListVoxelsQuery, ListVoxelsQueryVariables>;
export declare const RollbackVoxelUpdatesDocument: DocumentNode<RollbackVoxelUpdatesMutation, RollbackVoxelUpdatesMutationVariables>;
export declare const UpdateVoxelDocument: DocumentNode<UpdateVoxelMutation, UpdateVoxelMutationVariables>;
export declare const VoxelUpdateHistoryDocument: DocumentNode<VoxelUpdateHistoryQuery, VoxelUpdateHistoryQueryVariables>;
export declare const VoxelUpdateHistoryConnectionDocument: DocumentNode<VoxelUpdateHistoryConnectionQuery, VoxelUpdateHistoryConnectionQueryVariables>;
export {};
//# sourceMappingURL=graphql.d.ts.map