@crowdedkingdoms/crowdyjs 13.0.2 → 13.2.0

package/dist/generated/graphql.d.ts

@@ -3307,11 +3307,30 @@ export type FunctionPermissionEffectInput = {
     /** 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'];
     /** 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. */
@@ -3569,17 +3588,21 @@ export type GmAutomationPolicy = {
     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. */
-    automationId: Scalars['String']['output'];
-    /** The automation name at run time. */
+    /** 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'];
@@ -3613,7 +3636,9 @@ export type GmAutomationRun = {
     success: Scalars['Boolean']['output'];
     /** Number of target containers acted on (fan-out). */
     targets: Scalars['Int']['output'];
-    /** What triggered the run: schedule | event | manual | cascade. */
+    /** 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. */
@@ -3671,12 +3696,20 @@ export type GmAutomationTrigger = {
     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 = {
@@ -3863,6 +3896,8 @@ export type GmFunction = {
     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']>;
 };
@@ -3916,6 +3951,20 @@ export type GmFunctionPermissionEffect = {
     /** 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';
@@ -4039,6 +4088,42 @@ export type GmTierFeature = {
     /** 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';
@@ -4722,6 +4807,8 @@ export type Mutation = {
     forceLogoutUser: Scalars['Boolean']['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. */
@@ -4754,6 +4841,8 @@ export type Mutation = {
     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'). */
@@ -5327,6 +5416,11 @@ export type MutationForceLogoutUserArgs = {
 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;
 };
@@ -5384,6 +5478,9 @@ export type MutationGameModelRunAutomationArgs = {
     appId: Scalars['BigInt']['input'];
     name: Scalars['String']['input'];
 };
+export type MutationGameModelScheduleInvokeArgs = {
+    input: ScheduleInvokeInput;
+};
 export type MutationGameModelSeedArgs = {
     input: SeedGameModelInput;
 };
@@ -7070,6 +7167,8 @@ export type Query = {
     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'). */
@@ -7630,6 +7729,11 @@ 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']>;
@@ -8145,6 +8249,23 @@ export type SavedPaymentMethod = {
     /** 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. */
@@ -8216,6 +8337,8 @@ export type SeedFunctionInput = {
     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 = {
@@ -8382,6 +8505,8 @@ export type ServerStatus = {
     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. */
@@ -8490,8 +8615,12 @@ export type SetAutomationPolicyInput = {
     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 = {
@@ -8903,6 +9032,13 @@ export type TeleportResponse = {
     /** 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'];
@@ -9230,16 +9366,18 @@ export type UpsertAutomationTriggerInput = {
     appId: Scalars['BigInt']['input'];
     /** The automation (by name) this trigger fires. */
     automationName: Scalars['String']['input'];
-    /** Filter: only this container type. Rejected for player_count_changed. */
+    /** 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. Rejected for player_count_changed. */
+    /** 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. Rejected for player_count_changed. */
+    /** 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 = {
@@ -9326,6 +9464,8 @@ export type UpsertFunctionInput = {
     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 = {
@@ -14652,7 +14792,11 @@ export type GmAutomationTriggerFieldsFragment = {
     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';
@@ -14663,15 +14807,18 @@ export type GmAutomationPolicyFieldsFragment = {
     maxFanout: number;
     maxCascadeDepth: number;
     globalRunsPerMinute: number;
+    minTimerDelayMs: number;
+    maxPendingTimers: number;
 };
 export type GmAutomationRunFieldsFragment = {
     __typename?: 'GmAutomationRun';
     runId: string;
     appId: string;
     flowId: string | null;
-    automationId: string;
+    automationId: string | null;
     automationName: string;
     triggerSource: string;
+    triggerId: string | null;
     parentRunId: string | null;
     cascadeDepth: number;
     startedAt: string;
@@ -14795,7 +14942,11 @@ export type GameModelUpsertAutomationTriggerMutation = {
         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<{
@@ -14820,6 +14971,8 @@ export type GameModelSetAutomationPolicyMutation = {
         maxFanout: number;
         maxCascadeDepth: number;
         globalRunsPerMinute: number;
+        minTimerDelayMs: number;
+        maxPendingTimers: number;
     };
 };
 export type GameModelRunAutomationMutationVariables = Exact<{
@@ -14833,9 +14986,10 @@ export type GameModelRunAutomationMutation = {
         runId: string;
         appId: string;
         flowId: string | null;
-        automationId: string;
+        automationId: string | null;
         automationName: string;
         triggerSource: string;
+        triggerId: string | null;
         parentRunId: string | null;
         cascadeDepth: number;
         startedAt: string;
@@ -14952,7 +15106,11 @@ export type GameModelAutomationTriggersQuery = {
         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<{
@@ -14969,6 +15127,8 @@ export type GameModelAutomationPolicyQuery = {
         maxFanout: number;
         maxCascadeDepth: number;
         globalRunsPerMinute: number;
+        minTimerDelayMs: number;
+        maxPendingTimers: number;
     };
 };
 export type GameModelAutomationRunsQueryVariables = Exact<{
@@ -14985,9 +15145,10 @@ export type GameModelAutomationRunsQuery = {
         runId: string;
         appId: string;
         flowId: string | null;
-        automationId: string;
+        automationId: string | null;
         automationName: string;
         triggerSource: string;
+        triggerId: string | null;
         parentRunId: string | null;
         cascadeDepth: number;
         startedAt: string;
@@ -15059,6 +15220,74 @@ export type GameModelAppDiagnosticsQuery = {
         }>;
     };
 };
+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'];
 }>;
@@ -15504,9 +15733,10 @@ export type GameModelFlowQuery = {
             runId: string;
             appId: string;
             flowId: string | null;
-            automationId: string;
+            automationId: string | null;
             automationName: string;
             triggerSource: string;
+            triggerId: string | null;
             parentRunId: string | null;
             cascadeDepth: number;
             startedAt: string;
@@ -15590,6 +15820,18 @@ export type GmFunctionFieldsFragment = {
         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';
@@ -15719,6 +15961,18 @@ export type GameModelUpsertFunctionMutation = {
             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<{
@@ -15831,6 +16085,18 @@ export type GameModelTypeSchemaQuery = {
                 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;
+                }>;
+            }>;
         }>;
     };
 };
@@ -15920,6 +16186,18 @@ export type GameModelFunctionQuery = {
             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<{
@@ -15974,6 +16252,18 @@ export type GameModelFunctionsQuery = {
             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<{
@@ -19725,6 +20015,7 @@ export declare const GmAutomationFieldsFragmentDoc: DocumentNode<GmAutomationFie
 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>;
@@ -19902,6 +20193,9 @@ export declare const GameModelAutomationPolicyDocument: DocumentNode<GameModelAu
 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>;