@crowdedkingdoms/crowdyjs 17.9.0-dev.1 → 17.11.0-dev.1

package/dist/generated/graphql.d.ts

@@ -3619,6 +3619,18 @@ export type ExchangePortalCodeInput = {
     /** 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']>;
 };
+/** Whether an app’s ck-exec code may run: its active version and its switches (dev-tier preview). */
+export type ExecAppStatus = {
+    __typename?: 'ExecAppStatus';
+    /** The active version; null before the first deploy. */
+    activeVersion: Maybe<Scalars['Int']['output']>;
+    /** Paused while the app is over its compute budget; it resumes by itself once a minute is back under it. */
+    budgetPaused: Scalars['Boolean']['output'];
+    /** The whole app is switched off (`execSetEnabled` without a node type). */
+    disabled: Scalars['Boolean']['output'];
+    /** Node types switched off one by one. */
+    disabledTypes: Array<Scalars['String']['output']>;
+};
 /** One compiled module for a ck-exec deploy. */
 export type ExecArtifactInput = {
     /** SHA-256 of the WASM, 64 hex characters; the manager checks it. */
@@ -3626,6 +3638,55 @@ export type ExecArtifactInput = {
     /** The WASM module (wasm32-unknown-unknown, built with ckx-sdk), base64. */
     wasmBase64: Scalars['String']['input'];
 };
+/** A ck-exec build (dev-tier preview): queued, building, succeeded or failed, with the compiler’s log and, once it succeeds, one module per crate. */
+export type ExecBuild = {
+    __typename?: 'ExecBuild';
+    /** The modules built so far, one per crate. */
+    artifacts: Array<ExecBuildArtifact>;
+    /** The build’s id, for `execBuildStatus` and `execDeploy`. */
+    buildId: Scalars['String']['output'];
+    /** When the build was requested. */
+    createdAt: Scalars['DateTime']['output'];
+    /** When it finished. */
+    finishedAt: Maybe<Scalars['DateTime']['output']>;
+    /** The compiler’s output once the build finishes, at most 64 KB (the end is kept). */
+    log: Maybe<Scalars['String']['output']>;
+    /** When it started compiling. */
+    startedAt: Maybe<Scalars['DateTime']['output']>;
+    /** `queued`, `building`, `succeeded` or `failed`. */
+    status: Scalars['String']['output'];
+};
+/** One module a ck-exec build produced. */
+export type ExecBuildArtifact = {
+    __typename?: 'ExecBuildArtifact';
+    /** The crate it was built from. */
+    crate: Scalars['String']['output'];
+    /** SHA-256 of the WASM: the `digest` a manifest names it by. */
+    digest: Scalars['String']['output'];
+    /** The module’s size in bytes. */
+    sizeBytes: Scalars['Int']['output'];
+};
+/** One crate of a ck-exec build: a `ckx-sdk` library with `[lib] crate-type = ["cdylib"]`, built into one module. */
+export type ExecBuildCrateInput = {
+    /** Its files, at most 64. `Cargo.toml` may have only [package], [lib] and [dependencies] from `ckx-sdk`, `serde` and `serde_json`. */
+    files: Array<ExecBuildFileInput>;
+    /** The crate’s name: lowercase letters, digits, `-` or `_`, at most 64 characters. The build reports each module under it. */
+    name: Scalars['String']['input'];
+};
+/** One source file of a ck-exec crate. */
+export type ExecBuildFileInput = {
+    /** The file’s contents, UTF-8. */
+    content: Scalars['String']['input'];
+    /** The path within the crate: `Cargo.toml`, `README.md`, or a `.rs` file under `src/`. */
+    path: Scalars['String']['input'];
+};
+/** Sources to build into ck-exec modules. */
+export type ExecBuildInput = {
+    /** The app to build for. */
+    appId: Scalars['BigInt']['input'];
+    /** The crates, at most 16, 2 MB of source in all; each becomes one module. */
+    crates: Array<ExecBuildCrateInput>;
+};
 /** Where and how a game client connects to ck-exec, the hub-and-spoke execution service (dev-tier preview). Open a WebSocket to `{gatewayUrl}/v1/connect?token={token}` before `expiresAt`. */
 export type ExecConnection = {
     __typename?: 'ExecConnection';
@@ -3644,7 +3705,9 @@ export type ExecDeployInput = {
     appId: Scalars['BigInt']['input'];
     /** Modules the manifest names that this app has not uploaded before (at most 64). A request body is limited to 10 MB, so about 7 MB of modules per call. */
     artifacts?: InputMaybe<Array<ExecArtifactInput>>;
-    /** The manifest as JSON: `{ "root": "<hub type>", "types": { "<name>": { "kind": "hub"|"spoke", "parent", "digest", "client", "calls", ... } } }`. See the ck-exec repo’s `ckx-control` crate for every field and its platform bounds. */
+    /** A succeeded `execBuild` of this app whose modules to include, so a manifest can name them by digest without uploading them. */
+    buildId?: InputMaybe<Scalars['String']['input']>;
+    /** The manifest as JSON: `{ "root": "<hub type>", "types": { "<name>": { "kind": "hub"|"spoke", "parent", "digest", "client", "calls", "scopes", ... } } }`; with `buildId`, a type may give `"crate": "<name>"` instead of `digest`. Every field and its platform bounds: https://docs.dev.crowdedkingdoms.com/exec/intro#the-manifest. */
     manifestJson: Scalars['String']['input'];
 };
 /** The result of a ck-exec deploy. */
@@ -3653,6 +3716,85 @@ export type ExecDeployResult = {
     /** The version now active for the app. */
     version: Scalars['Int']['output'];
 };
+/** An instance the execution manager has placed for an app (dev-tier preview). */
+export type ExecInstance = {
+    __typename?: 'ExecInstance';
+    /** Rises each time it is placed; snapshots from an older epoch are refused. */
+    epoch: Scalars['Int']['output'];
+    /** Why the manager will not place it right now (a crash loop, a failed start), when it will not. */
+    heldBack: Maybe<Scalars['String']['output']>;
+    /** The execution host it runs on; null while idle. */
+    host: Maybe<Scalars['String']['output']>;
+    /** The instance id. */
+    instanceId: Scalars['String']['output'];
+    /** The instance key; empty for the root hub. */
+    key: Scalars['String']['output'];
+    /** `hub` or `spoke`. */
+    kind: Scalars['String']['output'];
+    nodeType: Scalars['String']['output'];
+    /** `idle`, `starting`, `running` or `stopping`. */
+    phase: Scalars['String']['output'];
+    /** Milliseconds since it entered this phase. */
+    sinceMs: Scalars['Float']['output'];
+};
+/** One guest log line from an app’s ck-exec instances (`ctx.log`), kept for 24 hours (dev-tier preview). */
+export type ExecLogLine = {
+    __typename?: 'ExecLogLine';
+    /** When the instance logged it. */
+    at: Scalars['DateTime']['output'];
+    /** The execution host it ran on. */
+    host: Scalars['String']['output'];
+    /** The line’s id, time-ordered: pass the oldest one you have as `before` to page back. */
+    id: Scalars['String']['output'];
+    /** The instance key. */
+    key: Scalars['String']['output'];
+    /** 0 error, 1 warn, 2 info, 3 debug. */
+    level: Scalars['Int']['output'];
+    /** The node type that logged it; empty for a platform note (lines dropped over a rate). */
+    nodeType: Scalars['String']['output'];
+    /** The line, at most 1 KiB. */
+    text: Scalars['String']['output'];
+};
+/** A starter crate: a ckx-sdk hub to build with `execBuild` as it is, or to change first. */
+export type ExecStarter = {
+    __typename?: 'ExecStarter';
+    /** The crate’s name, which the pack’s manifest names it by. */
+    crate: Scalars['String']['output'];
+    /** What it does. */
+    description: Scalars['String']['output'];
+    /** Its Cargo.toml and sources. */
+    files: Array<ExecStarterFile>;
+    /** The node type the pack’s manifest deploys it as. */
+    nodeType: Scalars['String']['output'];
+};
+/** One source file of a starter crate. */
+export type ExecStarterFile = {
+    __typename?: 'ExecStarterFile';
+    /** The file’s contents. */
+    content: Scalars['String']['output'];
+    /** The path within the crate, as `execBuild` takes it. */
+    path: Scalars['String']['output'];
+};
+/** The starter packs (dev-tier preview): four crates and a manifest that deploys them as one app. */
+export type ExecStarterPack = {
+    __typename?: 'ExecStarterPack';
+    /** The manifest for `execDeploy` with the build’s id: the root `world` hub, and `matchmaker`, `session` and `npcs` under it, each naming its crate. */
+    manifestJson: Scalars['String']['output'];
+    /** The crates. */
+    starters: Array<ExecStarter>;
+};
+/** A deployed version of an app’s ck-exec topology. */
+export type ExecVersion = {
+    __typename?: 'ExecVersion';
+    /** Whether it is the active version. */
+    active: Scalars['Boolean']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    /** Who deployed it, e.g. `user:<id>`. */
+    createdBy: Maybe<Scalars['String']['output']>;
+    /** Node types in its manifest. */
+    types: Scalars['Int']['output'];
+    version: Scalars['Int']['output'];
+};
 /** An org's free shared app slot quota usage. */
 export type FreeAppQuota = {
     __typename?: 'FreeAppQuota';
@@ -5524,10 +5666,18 @@ export type Mutation = {
     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;
+    /** Make an earlier ck-exec version active again, a rollback (dev-tier preview). Running instances pick it up when they next start, as after a deploy. Requires the org 'manage_compute' permission. */
+    execActivateVersion: ExecAppStatus;
+    /** Build ck-exec modules from Rust source (dev-tier preview): each crate is compiled with the platform's pinned toolchain and `ckx-sdk`, for wasm32-unknown-unknown, and checked against the guest ABI. Returns at once with the build queued; poll `execBuildStatus`, then pass its id to `execDeploy`. Requires the org 'manage_compute' permission. */
+    execBuild: ExecBuild;
     /** Connect a player to ck-exec (dev-tier preview): the execution manager picks a host (the one running `nodeType`/`key` when given, placing it if needed) and this returns its gateway and a 60-second connect token bound to this player, this app and that host. Requires the app-scoped token of the app named. */
     execConnect: ExecConnection;
+    /** Connect to an app's ck-exec code as one of its developers, for studio tools, manual runs and admin endpoints (dev-tier preview). The session's calls arrive as `Caller::Developer` with your user id and may reach any node type, not only `client` ones, but never the platform's `$` methods. Requires the org 'manage_compute' permission and your own session, not an app token. */
+    execConnectAsDeveloper: ExecConnection;
     /** Deploy a new version of an app's ck-exec topology (dev-tier preview): the manifest and any modules it names that were not uploaded before. The execution manager checks the manifest's tree and bounds and each module's digest, stores them, and makes the version active; running instances pick it up when they next start. Requires the org 'manage_compute' permission. */
     execDeploy: ExecDeployResult;
+    /** The kill switch for an app's ck-exec code, or one node type of it (dev-tier preview). Switched off, nothing of it is placed, what runs is persisted and stopped, and calls are refused with `Denied`; switched on, instances start as they are called. Requires the org 'manage_compute' permission. */
+    execSetEnabled: ExecAppStatus;
     /** 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. */
@@ -6139,14 +6289,31 @@ export type MutationDeleteUserAppStateArgs = {
 export type MutationExchangePortalCodeArgs = {
     input: ExchangePortalCodeInput;
 };
+export type MutationExecActivateVersionArgs = {
+    appId: Scalars['BigInt']['input'];
+    version: Scalars['Int']['input'];
+};
+export type MutationExecBuildArgs = {
+    input: ExecBuildInput;
+};
 export type MutationExecConnectArgs = {
     appId: Scalars['BigInt']['input'];
     key?: InputMaybe<Scalars['String']['input']>;
     nodeType?: InputMaybe<Scalars['String']['input']>;
 };
+export type MutationExecConnectAsDeveloperArgs = {
+    appId: Scalars['BigInt']['input'];
+    key?: InputMaybe<Scalars['String']['input']>;
+    nodeType?: InputMaybe<Scalars['String']['input']>;
+};
 export type MutationExecDeployArgs = {
     input: ExecDeployInput;
 };
+export type MutationExecSetEnabledArgs = {
+    appId: Scalars['BigInt']['input'];
+    enabled: Scalars['Boolean']['input'];
+    nodeType?: InputMaybe<Scalars['String']['input']>;
+};
 export type MutationForceLogoutUserArgs = {
     userId: Scalars['BigInt']['input'];
 };
@@ -8123,6 +8290,18 @@ export type Query = {
     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;
+    /** Whether an app's ck-exec code may run: its active version, kill switches and budget pause (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
+    execAppStatus: ExecAppStatus;
+    /** A ck-exec build's status, compiler log and modules (dev-tier preview); null when this app has no such build. Builds are kept for 7 days. Requires the org 'view_compute_diagnostics' permission. */
+    execBuildStatus: Maybe<ExecBuild>;
+    /** What the execution manager has placed for an app: every instance, its phase and host (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
+    execInstances: Array<ExecInstance>;
+    /** Guest log lines from an app's ck-exec instances (`ctx.log`), newest first, kept for 24 hours (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
+    execLogs: Array<ExecLogLine>;
+    /** The starter packs (dev-tier preview), which replace the compute templates: a world tick (the root hub: clock, weather, resource nodes, liveops events), a matchmaker, game sessions (lobby, host, turns, scores) and an NPC and mob engine, as ckx-sdk crates to pass to `execBuild` and a manifest for `execDeploy`. Requires the org 'manage_compute' permission. */
+    execStarters: ExecStarterPack;
+    /** An app's deployed ck-exec versions, newest first, and which is active (dev-tier preview). Requires the org 'view_compute_diagnostics' permission. */
+    execVersions: Array<ExecVersion>;
     /** 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. */
@@ -8697,6 +8876,30 @@ export type QueryEmailDeliverabilityArgs = {
     email: Scalars['String']['input'];
     eventLimit?: InputMaybe<Scalars['Int']['input']>;
 };
+export type QueryExecAppStatusArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecBuildStatusArgs = {
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+};
+export type QueryExecInstancesArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecLogsArgs = {
+    appId: Scalars['BigInt']['input'];
+    before?: InputMaybe<Scalars['String']['input']>;
+    key?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    maxLevel?: InputMaybe<Scalars['Int']['input']>;
+    nodeType?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryExecStartersArgs = {
+    appId: Scalars['BigInt']['input'];
+};
+export type QueryExecVersionsArgs = {
+    appId: Scalars['BigInt']['input'];
+};
 export type QueryGameClientBootstrapArgs = {
     appId: Scalars['BigInt']['input'];
 };
@@ -13975,6 +14178,202 @@ export type ExecDeployMutation = {
         version: number;
     };
 };
+export type ExecConnectAsDeveloperMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    nodeType?: InputMaybe<Scalars['String']['input']>;
+    key?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ExecConnectAsDeveloperMutation = {
+    __typename?: 'Mutation';
+    execConnectAsDeveloper: {
+        __typename?: 'ExecConnection';
+        gatewayUrl: string;
+        token: string;
+        host: string;
+        expiresAt: string;
+    };
+};
+export type ExecLogsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    nodeType?: InputMaybe<Scalars['String']['input']>;
+    key?: InputMaybe<Scalars['String']['input']>;
+    maxLevel?: InputMaybe<Scalars['Int']['input']>;
+    before?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type ExecLogsQuery = {
+    __typename?: 'Query';
+    execLogs: Array<{
+        __typename?: 'ExecLogLine';
+        id: string;
+        nodeType: string;
+        key: string;
+        level: number;
+        host: string;
+        at: string;
+        text: string;
+    }>;
+};
+export type ExecInstancesQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecInstancesQuery = {
+    __typename?: 'Query';
+    execInstances: Array<{
+        __typename?: 'ExecInstance';
+        instanceId: string;
+        nodeType: string;
+        key: string;
+        kind: string;
+        phase: string;
+        host: string | null;
+        epoch: number;
+        sinceMs: number;
+        heldBack: string | null;
+    }>;
+};
+export type ExecVersionsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecVersionsQuery = {
+    __typename?: 'Query';
+    execVersions: Array<{
+        __typename?: 'ExecVersion';
+        version: number;
+        createdBy: string | null;
+        createdAt: string;
+        types: number;
+        active: boolean;
+    }>;
+};
+export type ExecAppStatusFieldsFragment = {
+    __typename?: 'ExecAppStatus';
+    activeVersion: number | null;
+    disabled: boolean;
+    disabledTypes: Array<string>;
+    budgetPaused: boolean;
+};
+export type ExecAppStatusQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecAppStatusQuery = {
+    __typename?: 'Query';
+    execAppStatus: {
+        __typename?: 'ExecAppStatus';
+        activeVersion: number | null;
+        disabled: boolean;
+        disabledTypes: Array<string>;
+        budgetPaused: boolean;
+    };
+};
+export type ExecActivateVersionMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    version: Scalars['Int']['input'];
+}>;
+export type ExecActivateVersionMutation = {
+    __typename?: 'Mutation';
+    execActivateVersion: {
+        __typename?: 'ExecAppStatus';
+        activeVersion: number | null;
+        disabled: boolean;
+        disabledTypes: Array<string>;
+        budgetPaused: boolean;
+    };
+};
+export type ExecSetEnabledMutationVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    enabled: Scalars['Boolean']['input'];
+    nodeType?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ExecSetEnabledMutation = {
+    __typename?: 'Mutation';
+    execSetEnabled: {
+        __typename?: 'ExecAppStatus';
+        activeVersion: number | null;
+        disabled: boolean;
+        disabledTypes: Array<string>;
+        budgetPaused: boolean;
+    };
+};
+export type ExecStartersQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+}>;
+export type ExecStartersQuery = {
+    __typename?: 'Query';
+    execStarters: {
+        __typename?: 'ExecStarterPack';
+        manifestJson: string;
+        starters: Array<{
+            __typename?: 'ExecStarter';
+            crate: string;
+            nodeType: string;
+            description: string;
+            files: Array<{
+                __typename?: 'ExecStarterFile';
+                path: string;
+                content: string;
+            }>;
+        }>;
+    };
+};
+export type ExecBuildFieldsFragment = {
+    __typename?: 'ExecBuild';
+    buildId: string;
+    status: string;
+    log: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    artifacts: Array<{
+        __typename?: 'ExecBuildArtifact';
+        crate: string;
+        digest: string;
+        sizeBytes: number;
+    }>;
+};
+export type ExecBuildMutationVariables = Exact<{
+    input: ExecBuildInput;
+}>;
+export type ExecBuildMutation = {
+    __typename?: 'Mutation';
+    execBuild: {
+        __typename?: 'ExecBuild';
+        buildId: string;
+        status: string;
+        log: string | null;
+        createdAt: string;
+        startedAt: string | null;
+        finishedAt: string | null;
+        artifacts: Array<{
+            __typename?: 'ExecBuildArtifact';
+            crate: string;
+            digest: string;
+            sizeBytes: number;
+        }>;
+    };
+};
+export type ExecBuildStatusQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    buildId: Scalars['String']['input'];
+}>;
+export type ExecBuildStatusQuery = {
+    __typename?: 'Query';
+    execBuildStatus: {
+        __typename?: 'ExecBuild';
+        buildId: string;
+        status: string;
+        log: string | null;
+        createdAt: string;
+        startedAt: string | null;
+        finishedAt: string | null;
+        artifacts: Array<{
+            __typename?: 'ExecBuildArtifact';
+            crate: string;
+            digest: string;
+            sizeBytes: number;
+        }>;
+    } | null;
+};
 export type GridOwnershipFieldsFragment = {
     __typename?: 'GridOwnership';
     gridOwnershipId: string;
@@ -20131,6 +20530,8 @@ export declare const ComputeTriggerFieldsFragmentDoc: DocumentNode<ComputeTrigge
 export declare const ComputePolicyFieldsFragmentDoc: DocumentNode<ComputePolicyFieldsFragment, unknown>;
 export declare const ComputeRunFieldsFragmentDoc: DocumentNode<ComputeRunFieldsFragment, unknown>;
 export declare const CrowdyStudioProjectFieldsFragmentDoc: DocumentNode<CrowdyStudioProjectFieldsFragment, unknown>;
+export declare const ExecAppStatusFieldsFragmentDoc: DocumentNode<ExecAppStatusFieldsFragment, unknown>;
+export declare const ExecBuildFieldsFragmentDoc: DocumentNode<ExecBuildFieldsFragment, unknown>;
 export declare const GridOwnershipFieldsFragmentDoc: DocumentNode<GridOwnershipFieldsFragment, unknown>;
 export declare const GmAutomationFieldsFragmentDoc: DocumentNode<GmAutomationFieldsFragment, unknown>;
 export declare const GmAutomationTriggerFieldsFragmentDoc: DocumentNode<GmAutomationTriggerFieldsFragment, unknown>;
@@ -20274,6 +20675,16 @@ export declare const CrowdyStudioCommonFilesDocument: DocumentNode<CrowdyStudioC
 export declare const CrowdyStudioProjectImportFileDocument: DocumentNode<CrowdyStudioProjectImportFileMutation, CrowdyStudioProjectImportFileMutationVariables>;
 export declare const ExecConnectDocument: DocumentNode<ExecConnectMutation, ExecConnectMutationVariables>;
 export declare const ExecDeployDocument: DocumentNode<ExecDeployMutation, ExecDeployMutationVariables>;
+export declare const ExecConnectAsDeveloperDocument: DocumentNode<ExecConnectAsDeveloperMutation, ExecConnectAsDeveloperMutationVariables>;
+export declare const ExecLogsDocument: DocumentNode<ExecLogsQuery, ExecLogsQueryVariables>;
+export declare const ExecInstancesDocument: DocumentNode<ExecInstancesQuery, ExecInstancesQueryVariables>;
+export declare const ExecVersionsDocument: DocumentNode<ExecVersionsQuery, ExecVersionsQueryVariables>;
+export declare const ExecAppStatusDocument: DocumentNode<ExecAppStatusQuery, ExecAppStatusQueryVariables>;
+export declare const ExecActivateVersionDocument: DocumentNode<ExecActivateVersionMutation, ExecActivateVersionMutationVariables>;
+export declare const ExecSetEnabledDocument: DocumentNode<ExecSetEnabledMutation, ExecSetEnabledMutationVariables>;
+export declare const ExecStartersDocument: DocumentNode<ExecStartersQuery, ExecStartersQueryVariables>;
+export declare const ExecBuildDocument: DocumentNode<ExecBuildMutation, ExecBuildMutationVariables>;
+export declare const ExecBuildStatusDocument: DocumentNode<ExecBuildStatusQuery, ExecBuildStatusQueryVariables>;
 export declare const GridOwnershipDocument: DocumentNode<GridOwnershipQuery, GridOwnershipQueryVariables>;
 export declare const AssignGridOwnershipDocument: DocumentNode<AssignGridOwnershipMutation, AssignGridOwnershipMutationVariables>;
 export declare const TransferGridOwnershipDocument: DocumentNode<TransferGridOwnershipMutation, TransferGridOwnershipMutationVariables>;