@spacefast/common 0.0.2

package/dist/contracts/builds.js

@@ -0,0 +1,248 @@
+import { z } from "zod";
+import { CursorPaginationSchema, baseDiagnosticSchema, cursorListQuerySchema, dataEnvelope, } from "./common.js";
+import { buildStatus } from "./enums.js";
+import { uploadInstructionsSchema } from "./internal.js";
+import { versionLogEntrySchema } from "./spaces.js";
+const nullableCommandSchema = z.string().trim().min(1).nullable();
+const buildTimeoutSecondsSchema = z.number().int().min(60).max(7200).default(900);
+const scpStyleGitRemotePattern = /^[^@\s/:]+@[^:\s]+:[^\s]+$/;
+const gitCloneUrlSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine((value) => scpStyleGitRemotePattern.test(value) || z.string().url().safeParse(value).success, "Clone URL must be a URL or scp-style Git remote.");
+// Build (`bld_`, internal-docs/platform.md "Build"): a first-class resource with
+// its own table; ids are opaque and NEVER derived from version ids. The runner
+// mints the produced version through the normal finalize path.
+export const BuildSettingsSchema = z
+    .object({
+    rootDirectory: nullableCommandSchema.default(null),
+    installDirectory: nullableCommandSchema.default(null),
+    installCommand: nullableCommandSchema.default(null),
+    buildCommand: nullableCommandSchema.default(null),
+    outputDirectory: nullableCommandSchema.default(null),
+    ignoredBuildCommand: nullableCommandSchema.default(null),
+    frameworkPreset: nullableCommandSchema.default(null),
+    platformPreset: nullableCommandSchema.default(null),
+    allowUnsupportedPlatformFeatures: z.boolean().default(false),
+    timeoutSeconds: buildTimeoutSecondsSchema,
+})
+    .describe("Resolved build settings. Builds persist this as an immutable settingsSnapshot.");
+export const BuildTargetSchema = z
+    .object({
+    channel: z
+        .string()
+        .trim()
+        .min(1)
+        .nullable()
+        .default(null)
+        .describe("Channel to promote when the build succeeds; null means no automatic promotion."),
+    preview: z.boolean().default(false).describe("Whether the build targets preview behavior."),
+})
+    .describe("Where a successful build should publish or preview.");
+const InternalBuildSourceSchema = z
+    .discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("git").describe("Legacy build input from a git repository."),
+        repo: z.string().describe("Repository identifier (e.g. owner/name or clone URL)."),
+        ref: z.string().describe("Branch, tag, or ref to build."),
+        commit: z.string().optional().describe("Exact commit built, once resolved."),
+    }),
+    z.object({
+        kind: z.literal("archive").describe("Build from an uploaded source archive."),
+        uploadId: z.string().optional().describe("Upload session (`upl_`) carrying the archive."),
+        sourceMetadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("Internal source provenance copied to the produced Version."),
+        objectKey: z.string().optional().describe("Internal staged archive object key."),
+        uploadedAt: z.string().datetime().optional().describe("When the archive finished staging."),
+        recoveredAt: z
+            .string()
+            .datetime()
+            .optional()
+            .describe("When an interrupted archive upload was recovered."),
+        sha256: z.string().optional().describe("SHA-256 checksum of the staged source archive."),
+        compressedBytes: z.number().int().nonnegative().optional(),
+        expandedBytes: z.number().int().nonnegative().optional(),
+        fileCount: z.number().int().nonnegative().optional(),
+        expiresAt: z
+            .string()
+            .datetime()
+            .optional()
+            .describe("Server-enforced upload expiry while the archive is waiting for upload."),
+    }),
+])
+    .describe("Legacy internal build source shape retained while build routes migrate to input.");
+const InternalBuildInputSchema = z
+    .discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("archive").describe("Build from an uploaded source archive."),
+        uploadId: z.string().optional().describe("Upload session (`upl_`) carrying the archive."),
+        sourceMetadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("Internal source provenance copied to the produced Version."),
+        objectKey: z.string().optional().describe("Internal staged archive object key."),
+        uploadedAt: z.string().datetime().optional().describe("When the archive finished staging."),
+        recoveredAt: z
+            .string()
+            .datetime()
+            .optional()
+            .describe("When an interrupted archive upload was recovered."),
+        sha256: z.string().optional().describe("SHA-256 checksum of the staged source archive."),
+        compressedBytes: z.number().int().nonnegative().optional(),
+        expandedBytes: z.number().int().nonnegative().optional(),
+        fileCount: z.number().int().nonnegative().optional(),
+        expiresAt: z
+            .string()
+            .datetime()
+            .optional()
+            .describe("Server-enforced upload expiry while the archive is waiting for upload."),
+    }),
+    z.object({
+        kind: z.literal("connected_repository").describe("Build from a repository connection."),
+        repositoryConnectionId: z.string().describe("Repository connection (`rpc_`) to build from."),
+        ref: z.string().describe("Branch, tag, or ref to build."),
+        commit: z.string().optional().describe("Exact commit built, once resolved."),
+        branch: z.string().optional().describe("Branch name when the ref is a commit SHA."),
+        pullRequestNumber: z.number().int().positive().optional(),
+        repository: z
+            .object({
+            provider: z.string(),
+            repositoryId: z.string().nullable(),
+            repositoryName: z.string().nullable(),
+            repositoryFullName: z.string().nullable(),
+            defaultBranch: z.string().nullable(),
+            productionBranch: z.string().nullable(),
+        })
+            .optional()
+            .describe("Immutable repository identity snapshot captured when the Build was created."),
+    }),
+    z.object({
+        kind: z.literal("git_url").describe("Build from a short-lived clone URL."),
+        cloneUrl: gitCloneUrlSchema.describe("Short-lived clone URL; do not persist credentials."),
+        ref: z.string().describe("Branch, tag, or ref to build."),
+        commit: z.string().optional().describe("Exact commit built, once resolved."),
+    }),
+])
+    .describe("What the build runs against.");
+export const PublicBuildInputSchema = z
+    .discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("archive").describe("Build from an uploaded source archive."),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z
+            .literal("repository")
+            .describe("Build from repository source where clone credentials are not exposed."),
+        ref: z.string().describe("Branch, tag, or ref to build."),
+        commit: z.string().optional().describe("Exact commit built, once resolved."),
+        branch: z.string().optional().describe("Branch name when available."),
+        pullRequestNumber: z.number().int().positive().optional(),
+    })
+        .strict(),
+])
+    .describe("Public build input. Internal clone URLs and staged object keys are not exposed.");
+export const BuildCreateInputSchema = z
+    .discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("archive").describe("Build from an uploaded source archive."),
+        sourceMetadata: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("Optional source provenance for the produced Version."),
+    })
+        .strict(),
+    z.object({
+        kind: z.literal("repository").describe("Build from a repository connection."),
+        repositoryConnectionId: z.string().describe("Repository connection (`rpc_`) to build from."),
+        ref: z.string().optional().describe("Branch, tag, or ref to build."),
+        commit: z.string().optional().describe("Exact commit built, once resolved."),
+        branch: z.string().optional().describe("Branch name when the ref is a commit SHA."),
+        pullRequestNumber: z.number().int().positive().optional(),
+    }),
+])
+    .describe("What a new build should run against.");
+const InternalBuildExecutionSchema = z
+    .object({
+    runner: z.string().nullable().default(null),
+    runnerJobId: z.string().nullable().default(null),
+    sandboxId: z.string().nullable().default(null),
+    region: z.string().nullable().default(null),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+})
+    .describe("Internal runner execution metadata surfaced only where appropriate.");
+export const BuildSchema = z.object({
+    id: z.string().describe("Build id (`bld_`); opaque, never derived from a version id."),
+    spaceId: z.string().describe("Space (`spc_`) the build produces a version for."),
+    status: buildStatus.describe("Build lifecycle status."),
+    input: PublicBuildInputSchema,
+    settingsSnapshot: BuildSettingsSchema,
+    target: BuildTargetSchema,
+    retryOfBuildId: z
+        .string()
+        .nullable()
+        .default(null)
+        .describe("Original build retried by this build."),
+    producedVersionId: z
+        .string()
+        .nullable()
+        .describe("Version (`ver_`) minted by a succeeded build; null otherwise."),
+    reusedVersionId: z
+        .string()
+        .nullable()
+        .default(null)
+        .describe("Existing version reused by a succeeded no-change build; null otherwise."),
+    diagnostics: z.array(baseDiagnosticSchema).default([]),
+    createdAt: z.string().datetime(),
+    startedAt: z.string().datetime().nullable().describe("When the runner picked the build up."),
+    finishedAt: z.string().datetime().nullable().describe("When the build reached a terminal state."),
+});
+export const buildCreateRequestSchema = z.object({
+    input: BuildCreateInputSchema,
+    settings: BuildSettingsSchema.partial()
+        .optional()
+        .describe("Per-run settings overrides; persisted as settingsSnapshot after resolution."),
+    target: BuildTargetSchema.partial().optional(),
+    diagnostics: z
+        .array(baseDiagnosticSchema)
+        .optional()
+        .describe("Optional diagnostics already known before the build is queued."),
+    wait: z.boolean().default(false),
+});
+export const buildSourceArchiveUploadSchema = uploadInstructionsSchema;
+export const buildCreateResponseSchema = dataEnvelope(z.object({
+    build: BuildSchema,
+    upload: buildSourceArchiveUploadSchema.nullable().default(null),
+}));
+export const buildListQuerySchema = cursorListQuerySchema;
+export const buildListResponseSchema = z.object({
+    data: z.array(BuildSchema),
+    pagination: CursorPaginationSchema,
+});
+// Build logs share the ONE runtime log-entry shape with version logs (spec
+// "Log routes"): plain cursor-list params, no bespoke LogQuery type.
+export const buildLogListResponseSchema = z.object({
+    data: z.array(versionLogEntrySchema),
+    pagination: CursorPaginationSchema,
+});
+// Branch-to-channel integration config (spec "Lifecycle model": "branch-to-
+// channel mapping rules live on the Space as integration config"). Launch only
+// supports `live`; keep the stored config aligned with publish/finalize until
+// named channels ship.
+export const spaceBuildIntegrationSchema = z
+    .object({
+    branchChannels: z
+        .record(z.string().min(1).describe("Git branch or ref name."), z.literal("live").describe("Channel the branch's builds promote to."))
+        .describe("Exact branch/ref name to channel name, e.g. { main: 'live' }."),
+})
+    .describe("Per-space build integration config: where repository builds promote.");
+/** Channel a repository build promotes to, or null when the ref is unmapped (default channel applies). */
+export function resolveBuildChannel(integration, ref) {
+    return integration?.branchChannels[ref] ?? null;
+}

package/dist/contracts/channels.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const channelListItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    currentVersionId: z.ZodNullable<z.ZodString>;
+    currentDeploymentUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    previousVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ChannelListItem = z.infer<typeof channelListItemSchema>;
+export declare const channelHistoryEntrySchema: z.ZodObject<{
+    versionId: z.ZodString;
+    channel: z.ZodString;
+    previousVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    actorType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        user: "user";
+        api_key: "api_key";
+        oauth_client: "oauth_client";
+        anonymous_claim: "anonymous_claim";
+        system: "system";
+    }>>>;
+    actorId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    at: z.ZodString;
+}, z.core.$strip>;
+export type ChannelHistoryEntry = z.infer<typeof channelHistoryEntrySchema>;
+export declare const channelListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        currentDeploymentUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        previousVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const channelHistoryResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        versionId: z.ZodString;
+        channel: z.ZodString;
+        previousVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        actorType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            api_key: "api_key";
+            oauth_client: "oauth_client";
+            anonymous_claim: "anonymous_claim";
+            system: "system";
+        }>>>;
+        actorId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/contracts/channels.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+// Channels READ surface (internal-docs/platform.md "Channels"): a read-only
+// projection over the existing `channels` table and the `channel.promoted`
+// activity log. No writes, no new storage — promotion stays owned by the
+// publish/version lifecycle. Additive only.
+// One row of the channel list: where each named channel points right now.
+// `currentVersionId` is the live pointer (`channels.versionId`); weighted
+// pointers are not surfaced here yet (live-only at launch).
+export const channelListItemSchema = z.object({
+    name: z.string().describe("Channel name; `live` is the default channel."),
+    currentVersionId: z
+        .string()
+        .nullable()
+        .describe("Version this channel currently serves, or null before first publish."),
+    currentDeploymentUrl: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Immutable URL of the currently-served version, when known."),
+    previousVersionId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Last version this channel served before the current pointer (rollback target)."),
+    updatedAt: z.string().datetime().describe("When this channel pointer last moved."),
+});
+// One entry of a channel's promotion history (the deploy log): a single
+// `channel.promoted` event, newest first. This is the audit trail of every
+// pointer move on the channel.
+export const channelHistoryEntrySchema = z.object({
+    versionId: z.string().describe("Version the channel was promoted to."),
+    channel: z.string().describe("Channel that moved."),
+    previousVersionId: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Version the channel served immediately before this promotion."),
+    actorType: z
+        .enum(["user", "api_key", "oauth_client", "anonymous_claim", "system"])
+        .nullable()
+        .optional()
+        .describe("Kind of actor that performed the promotion."),
+    actorId: z.string().nullable().optional().describe("Identifier of the promoting actor."),
+    at: z.string().datetime().describe("When the promotion happened."),
+});
+export const channelListResponseSchema = z.object({
+    data: z.array(channelListItemSchema),
+});
+export const channelHistoryResponseSchema = z.object({
+    data: z.array(channelHistoryEntrySchema),
+});

package/dist/contracts/common.d.ts

@@ -0,0 +1,238 @@
+import { z } from "zod";
+export declare const AnyObjectSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const SpaceViewerSchema: z.ZodObject<{
+    title: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    ogImagePath: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const baseDiagnosticSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+        error: "error";
+    }>;
+    message: z.ZodString;
+    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        wpcloud: "wpcloud";
+        dns: "dns";
+        registrar: "registrar";
+        runtime: "runtime";
+    }>>>;
+    details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type Diagnostic = z.infer<typeof baseDiagnosticSchema>;
+export declare const DnsInstructionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        A: "A";
+        AAAA: "AAAA";
+        CNAME: "CNAME";
+        TXT: "TXT";
+        ALIAS: "ALIAS";
+    }>;
+    name: z.ZodString;
+    value: z.ZodString;
+    ttl: z.ZodOptional<z.ZodNumber>;
+    purpose: z.ZodEnum<{
+        verification: "verification";
+        routing: "routing";
+        ssl: "ssl";
+    }>;
+}, z.core.$strip>;
+export type DnsInstruction = z.infer<typeof DnsInstructionSchema>;
+export declare const requiredActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"dns">;
+    instructions: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            A: "A";
+            AAAA: "AAAA";
+            CNAME: "CNAME";
+            TXT: "TXT";
+            ALIAS: "ALIAS";
+        }>;
+        name: z.ZodString;
+        value: z.ZodString;
+        ttl: z.ZodOptional<z.ZodNumber>;
+        purpose: z.ZodEnum<{
+            verification: "verification";
+            routing: "routing";
+            ssl: "ssl";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"confirm_move">;
+    conflictId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"verify_domain">;
+    domainId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"renew">;
+    domainId: z.ZodString;
+}, z.core.$strip>], "type">;
+export type RequiredAction = z.infer<typeof requiredActionSchema>;
+export declare const requiredActionsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"dns">;
+    instructions: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            A: "A";
+            AAAA: "AAAA";
+            CNAME: "CNAME";
+            TXT: "TXT";
+            ALIAS: "ALIAS";
+        }>;
+        name: z.ZodString;
+        value: z.ZodString;
+        ttl: z.ZodOptional<z.ZodNumber>;
+        purpose: z.ZodEnum<{
+            verification: "verification";
+            routing: "routing";
+            ssl: "ssl";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"confirm_move">;
+    conflictId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"verify_domain">;
+    domainId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"renew">;
+    domainId: z.ZodString;
+}, z.core.$strip>], "type">>;
+export declare const ApiErrorResponseSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        param: z.ZodOptional<z.ZodString>;
+        docsUrl: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        suggestions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        requestId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function dataEnvelope<T extends z.ZodType>(data: T): z.ZodObject<{
+    data: T;
+}, z.core.$strip>;
+export declare const ApiUploadInstructionSchema: z.ZodObject<{
+    id: z.ZodString;
+    expiresAt: z.ZodString;
+    method: z.ZodLiteral<"PUT">;
+    url: z.ZodUnion<[z.ZodString, z.ZodString]>;
+    contentType: z.ZodString;
+    maxBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type ApiUploadInstruction = z.infer<typeof ApiUploadInstructionSchema>;
+export declare const CursorPaginationSchema: z.ZodObject<{
+    nextCursor: z.ZodNullable<z.ZodString>;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const cursorListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function makeOffsetListSchema<Key extends string, Item extends z.ZodType, Pagination extends z.ZodType>(itemsKey: Key, item: Item, pagination: Pagination): z.ZodObject<{ [K in Key]: z.ZodArray<Item>; } & {
+    total: z.ZodNumber;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+    pagination: Pagination;
+} extends infer T ? { -readonly [P in keyof T]: T[P]; } : never, z.core.$strip>;
+export declare const AsyncOperationProgressSchema: z.ZodObject<{
+    stage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nextCheckAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type AsyncOperationProgress = z.infer<typeof AsyncOperationProgressSchema>;
+export declare const OperationProgressSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    completed: z.ZodNumber;
+    failed: z.ZodNumber;
+}, z.core.$strip>;
+export declare const AsyncOperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        canceled: "canceled";
+    }>;
+    resources: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    progress: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            wpcloud: "wpcloud";
+            dns: "dns";
+            registrar: "registrar";
+            runtime: "runtime";
+        }>>>;
+        details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    finishedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AsyncOperation = z.infer<typeof AsyncOperationSchema>;
+export declare function mutationEnvelope<T extends z.ZodType>(data: T): z.ZodObject<{
+    data: T;
+    operation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            canceled: "canceled";
+        }>;
+        resources: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        progress: z.ZodOptional<z.ZodObject<{
+            total: z.ZodNumber;
+            completed: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strip>>;
+        diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                warning: "warning";
+                error: "error";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                wpcloud: "wpcloud";
+                dns: "dns";
+                registrar: "registrar";
+                runtime: "runtime";
+            }>>>;
+            details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            fix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            retryable: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;