@spacefast/common 0.0.21 → 0.0.24

package/dist/config/postgres-budget.d.ts

@@ -1,129 +0,0 @@
-import { z } from "zod";
-declare const postgresConnectionBudgetSchema: z.ZodObject<{
-    server: z.ZodObject<{
-        maxConnections: z.ZodNumber;
-        superuserReservedConnections: z.ZodNumber;
-    }, z.core.$strip>;
-    migrationConnections: z.ZodNumber;
-    operationalReserveConnections: z.ZodNumber;
-    transactionPools: z.ZodRecord<z.ZodString, z.ZodObject<{
-        serverConnections: z.ZodNumber;
-    }, z.core.$strip>>;
-    services: z.ZodObject<{
-        api: z.ZodObject<{
-            enabledInProduction: z.ZodBoolean;
-            replicas: z.ZodNumber;
-            poolConnectionsPerReplica: z.ZodNumber;
-            fixedConnectionsPerReplica: z.ZodNumber;
-            maxPinnedTransactionsPerReplica: z.ZodNumber;
-            rolloutOverlapReplicas: z.ZodNumber;
-            connectionBudget: z.ZodString;
-        }, z.core.$strip>;
-        worker: z.ZodObject<{
-            enabledInProduction: z.ZodBoolean;
-            replicas: z.ZodNumber;
-            poolConnectionsPerReplica: z.ZodNumber;
-            fixedConnectionsPerReplica: z.ZodNumber;
-            maxPinnedTransactionsPerReplica: z.ZodNumber;
-            rolloutOverlapReplicas: z.ZodNumber;
-            connectionBudget: z.ZodString;
-        }, z.core.$strip>;
-        cast: z.ZodObject<{
-            enabledInProduction: z.ZodBoolean;
-            replicas: z.ZodNumber;
-            poolConnectionsPerReplica: z.ZodNumber;
-            fixedConnectionsPerReplica: z.ZodNumber;
-            maxPinnedTransactionsPerReplica: z.ZodNumber;
-            rolloutOverlapReplicas: z.ZodNumber;
-            connectionBudget: z.ZodString;
-        }, z.core.$strip>;
-        scanWorker: z.ZodObject<{
-            enabledInProduction: z.ZodBoolean;
-            replicas: z.ZodNumber;
-            poolConnectionsPerReplica: z.ZodNumber;
-            fixedConnectionsPerReplica: z.ZodNumber;
-            maxPinnedTransactionsPerReplica: z.ZodNumber;
-            rolloutOverlapReplicas: z.ZodNumber;
-            connectionBudget: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type PostgresConnectionBudget = z.infer<typeof postgresConnectionBudgetSchema>;
-export type PostgresBudgetService = keyof PostgresConnectionBudget["services"];
-export type PostgresConnectionBudgetSummary = {
-    usableServerConnections: number;
-    directSteadyConnections: number;
-    transactionPoolConnections: number;
-    transactionPoolPinnedConnections: number;
-    transactionPoolQueryHeadroom: number;
-    steadyConnections: number;
-    rollingDeploySurgeConnections: number;
-    migrationConnections: number;
-    operationalReserveConnections: number;
-    plannedConnections: number;
-    unallocatedConnections: number;
-};
-export declare const POSTGRES_CONNECTION_BUDGET: {
-    server: {
-        maxConnections: number;
-        superuserReservedConnections: number;
-    };
-    migrationConnections: number;
-    operationalReserveConnections: number;
-    transactionPools: Record<string, {
-        serverConnections: number;
-    }>;
-    services: {
-        api: {
-            enabledInProduction: boolean;
-            replicas: number;
-            poolConnectionsPerReplica: number;
-            fixedConnectionsPerReplica: number;
-            maxPinnedTransactionsPerReplica: number;
-            rolloutOverlapReplicas: number;
-            connectionBudget: string;
-        };
-        worker: {
-            enabledInProduction: boolean;
-            replicas: number;
-            poolConnectionsPerReplica: number;
-            fixedConnectionsPerReplica: number;
-            maxPinnedTransactionsPerReplica: number;
-            rolloutOverlapReplicas: number;
-            connectionBudget: string;
-        };
-        cast: {
-            enabledInProduction: boolean;
-            replicas: number;
-            poolConnectionsPerReplica: number;
-            fixedConnectionsPerReplica: number;
-            maxPinnedTransactionsPerReplica: number;
-            rolloutOverlapReplicas: number;
-            connectionBudget: string;
-        };
-        scanWorker: {
-            enabledInProduction: boolean;
-            replicas: number;
-            poolConnectionsPerReplica: number;
-            fixedConnectionsPerReplica: number;
-            maxPinnedTransactionsPerReplica: number;
-            rolloutOverlapReplicas: number;
-            connectionBudget: string;
-        };
-    };
-};
-export declare function calculatePostgresConnectionBudget(plan: PostgresConnectionBudget, server?: {
-    maxConnections: number;
-    superuserReservedConnections: number;
-}): PostgresConnectionBudgetSummary;
-export declare function assertPostgresServiceConnectionUrl(service: PostgresBudgetService, rawUrl: string, options?: {
-    allowDirectDevelopmentConnection?: boolean;
-}): void;
-export declare function assertPostgresServicePoolBudget(service: PostgresBudgetService, configuredPoolConnections: number): void;
-export declare function assertPostgresServiceNamedLockBudget(service: PostgresBudgetService, configuredNamedLockTransactions: number): void;
-export declare function assertPostgresServerBudget(server: {
-    maxConnections: number;
-    superuserReservedConnections: number;
-}): PostgresConnectionBudgetSummary;
-export declare const POSTGRES_CONNECTION_BUDGET_SUMMARY: PostgresConnectionBudgetSummary;
-export {};

package/dist/config/postgres-budget.js

@@ -1,140 +0,0 @@
-import { z } from "zod";
-import budgetJson from "./postgres-budget.json" with { type: "json" };
-const serviceBudgetSchema = z.object({
-    enabledInProduction: z.boolean(),
-    replicas: z.number().int().nonnegative(),
-    poolConnectionsPerReplica: z.number().int().positive(),
-    fixedConnectionsPerReplica: z.number().int().nonnegative(),
-    maxPinnedTransactionsPerReplica: z.number().int().nonnegative(),
-    rolloutOverlapReplicas: z.number().int().nonnegative(),
-    connectionBudget: z.string().min(1),
-});
-const postgresConnectionBudgetSchema = z
-    .object({
-    server: z.object({
-        maxConnections: z.number().int().positive(),
-        superuserReservedConnections: z.number().int().nonnegative(),
-    }),
-    migrationConnections: z.number().int().positive(),
-    operationalReserveConnections: z.number().int().nonnegative(),
-    transactionPools: z.record(z.string().min(1), z.object({
-        serverConnections: z.number().int().positive(),
-    })),
-    services: z.object({
-        api: serviceBudgetSchema,
-        worker: serviceBudgetSchema,
-        cast: serviceBudgetSchema,
-        scanWorker: serviceBudgetSchema,
-    }),
-})
-    .superRefine((plan, context) => {
-    for (const [serviceName, service] of Object.entries(plan.services)) {
-        if (service.connectionBudget !== "direct" &&
-            !Object.hasOwn(plan.transactionPools, service.connectionBudget)) {
-            context.addIssue({
-                code: "custom",
-                message: `service ${serviceName} references unknown transaction pool ${service.connectionBudget}`,
-                path: ["services", serviceName, "connectionBudget"],
-            });
-        }
-    }
-    for (const [poolName, pool] of Object.entries(plan.transactionPools)) {
-        const maxPinnedTransactions = Object.values(plan.services)
-            .filter((service) => service.enabledInProduction && service.connectionBudget === poolName)
-            .reduce((total, service) => total +
-            (service.replicas + service.rolloutOverlapReplicas) *
-                service.maxPinnedTransactionsPerReplica, 0);
-        if (maxPinnedTransactions >= pool.serverConnections) {
-            context.addIssue({
-                code: "custom",
-                message: `transaction pool ${poolName} can pin ${maxPinnedTransactions}/${pool.serverConnections} server connections, leaving no callback query capacity`,
-                path: ["transactionPools", poolName, "serverConnections"],
-            });
-        }
-    }
-});
-export const POSTGRES_CONNECTION_BUDGET = postgresConnectionBudgetSchema.parse(budgetJson);
-function serviceFootprint(service) {
-    return service.poolConnectionsPerReplica + service.fixedConnectionsPerReplica;
-}
-export function calculatePostgresConnectionBudget(plan, server = plan.server) {
-    const usableServerConnections = server.maxConnections - server.superuserReservedConnections;
-    if (usableServerConnections <= 0) {
-        throw new Error(`postgres_connection_budget_invalid: maxConnections=${server.maxConnections} must exceed superuserReservedConnections=${server.superuserReservedConnections}`);
-    }
-    const directServices = Object.values(plan.services).filter((service) => service.enabledInProduction && service.connectionBudget === "direct");
-    const directSteadyConnections = directServices.reduce((total, service) => total + service.replicas * serviceFootprint(service), 0);
-    const transactionPoolConnections = Object.values(plan.transactionPools).reduce((total, pool) => total + pool.serverConnections, 0);
-    const transactionPoolPinnedConnections = Object.values(plan.services)
-        .filter((service) => service.enabledInProduction && service.connectionBudget !== "direct")
-        .reduce((total, service) => total +
-        (service.replicas + service.rolloutOverlapReplicas) *
-            service.maxPinnedTransactionsPerReplica, 0);
-    const transactionPoolQueryHeadroom = transactionPoolConnections - transactionPoolPinnedConnections;
-    const steadyConnections = directSteadyConnections + transactionPoolConnections;
-    const rollingDeploySurgeConnections = directServices.reduce((total, service) => total + service.rolloutOverlapReplicas * serviceFootprint(service), 0);
-    const plannedConnections = steadyConnections +
-        rollingDeploySurgeConnections +
-        plan.migrationConnections +
-        plan.operationalReserveConnections;
-    return {
-        usableServerConnections,
-        directSteadyConnections,
-        transactionPoolConnections,
-        transactionPoolPinnedConnections,
-        transactionPoolQueryHeadroom,
-        steadyConnections,
-        rollingDeploySurgeConnections,
-        migrationConnections: plan.migrationConnections,
-        operationalReserveConnections: plan.operationalReserveConnections,
-        plannedConnections,
-        unallocatedConnections: usableServerConnections - plannedConnections,
-    };
-}
-export function assertPostgresServiceConnectionUrl(service, rawUrl, options = {}) {
-    const parsed = new URL(rawUrl);
-    const hostname = parsed.hostname.toLowerCase();
-    const isLocalDevelopmentHost = hostname === "localhost" ||
-        hostname === "127.0.0.1" ||
-        hostname === "::1" ||
-        hostname === "[::1]" ||
-        (!hostname.includes(".") && !hostname.includes(":"));
-    if (options.allowDirectDevelopmentConnection && isLocalDevelopmentHost) {
-        return;
-    }
-    const serviceBudget = POSTGRES_CONNECTION_BUDGET.services[service];
-    if (!serviceBudget.enabledInProduction) {
-        throw new Error(`postgres_connection_budget_service_disabled: service=${service}; add its replicas and rollout overlap to the shared budget before production startup`);
-    }
-    const connectionBudget = serviceBudget.connectionBudget;
-    const port = parsed.port || "5432";
-    if (connectionBudget === "direct") {
-        if (port !== "5432") {
-            throw new Error(`postgres_connection_budget_url_mismatch: service=${service} planned=direct port=${port}`);
-        }
-        return;
-    }
-    if (port !== "6432") {
-        throw new Error(`postgres_connection_budget_url_mismatch: service=${service} planned=transaction_pool pool=${connectionBudget} port=${port}`);
-    }
-}
-export function assertPostgresServicePoolBudget(service, configuredPoolConnections) {
-    const expected = POSTGRES_CONNECTION_BUDGET.services[service].poolConnectionsPerReplica;
-    if (configuredPoolConnections !== expected) {
-        throw new Error(`postgres_connection_budget_pool_mismatch: service=${service} configured=${configuredPoolConnections} planned=${expected}; update the shared budget and every affected service in one change`);
-    }
-}
-export function assertPostgresServiceNamedLockBudget(service, configuredNamedLockTransactions) {
-    const expected = POSTGRES_CONNECTION_BUDGET.services[service].maxPinnedTransactionsPerReplica;
-    if (configuredNamedLockTransactions !== expected) {
-        throw new Error(`postgres_connection_budget_named_lock_mismatch: service=${service} configured=${configuredNamedLockTransactions} planned=${expected}`);
-    }
-}
-export function assertPostgresServerBudget(server) {
-    const summary = calculatePostgresConnectionBudget(POSTGRES_CONNECTION_BUDGET, server);
-    if (summary.unallocatedConnections < 0) {
-        throw new Error(`postgres_connection_budget_exceeded: planned=${summary.plannedConnections} usable=${summary.usableServerConnections} max=${server.maxConnections} superuserReserved=${server.superuserReservedConnections}`);
-    }
-    return summary;
-}
-export const POSTGRES_CONNECTION_BUDGET_SUMMARY = assertPostgresServerBudget(POSTGRES_CONNECTION_BUDGET.server);

package/dist/config/postgres-budget.json

@@ -1,51 +0,0 @@
-{
-    "server": {
-        "maxConnections": 25,
-        "superuserReservedConnections": 3
-    },
-    "migrationConnections": 1,
-    "operationalReserveConnections": 4,
-    "transactionPools": {
-        "controlPlaneRuntime": {
-            "serverConnections": 7
-        }
-    },
-    "services": {
-        "api": {
-            "enabledInProduction": true,
-            "replicas": 2,
-            "poolConnectionsPerReplica": 4,
-            "fixedConnectionsPerReplica": 0,
-            "maxPinnedTransactionsPerReplica": 1,
-            "rolloutOverlapReplicas": 1,
-            "connectionBudget": "controlPlaneRuntime"
-        },
-        "worker": {
-            "enabledInProduction": true,
-            "replicas": 1,
-            "poolConnectionsPerReplica": 4,
-            "fixedConnectionsPerReplica": 0,
-            "maxPinnedTransactionsPerReplica": 1,
-            "rolloutOverlapReplicas": 1,
-            "connectionBudget": "controlPlaneRuntime"
-        },
-        "cast": {
-            "enabledInProduction": true,
-            "replicas": 1,
-            "poolConnectionsPerReplica": 4,
-            "fixedConnectionsPerReplica": 1,
-            "maxPinnedTransactionsPerReplica": 0,
-            "rolloutOverlapReplicas": 1,
-            "connectionBudget": "direct"
-        },
-        "scanWorker": {
-            "enabledInProduction": false,
-            "replicas": 0,
-            "poolConnectionsPerReplica": 2,
-            "fixedConnectionsPerReplica": 0,
-            "maxPinnedTransactionsPerReplica": 1,
-            "rolloutOverlapReplicas": 0,
-            "connectionBudget": "controlPlaneRuntime"
-        }
-    }
-}

package/dist/contracts/archives.d.ts

@@ -1,331 +0,0 @@
-import { z } from "zod";
-export declare const archiveListQuerySchema: z.ZodObject<{
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const spaceExportRequestSchema: z.ZodObject<{
-    versionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    includeFiles: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const spaceExportArchiveSchema: z.ZodObject<{
-    contentType: z.ZodLiteral<"application/zip">;
-    downloadUrl: z.ZodString;
-    expiresAt: z.ZodString;
-    sizeBytes: z.ZodOptional<z.ZodNumber>;
-    sha256: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const spaceExportSchema: z.ZodObject<{
-    id: z.ZodString;
-    spaceId: z.ZodString;
-    status: z.ZodEnum<{
-        failed: "failed";
-        expired: "expired";
-        ready: "ready";
-        queued: "queued";
-        running: "running";
-    }>;
-    format: z.ZodLiteral<"spacefast_export_v1">;
-    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            warning: "warning";
-        }>;
-        message: z.ZodString;
-        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            registrar: "registrar";
-            wpcloud: "wpcloud";
-            dns: "dns";
-            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>>>;
-    archive: z.ZodOptional<z.ZodObject<{
-        contentType: z.ZodLiteral<"application/zip">;
-        downloadUrl: z.ZodString;
-        expiresAt: z.ZodString;
-        sizeBytes: z.ZodOptional<z.ZodNumber>;
-        sha256: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    operationId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-export declare const spaceExportListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        spaceId: z.ZodString;
-        status: z.ZodEnum<{
-            failed: "failed";
-            expired: "expired";
-            ready: "ready";
-            queued: "queued";
-            running: "running";
-        }>;
-        format: z.ZodLiteral<"spacefast_export_v1">;
-        diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            code: z.ZodString;
-            severity: z.ZodEnum<{
-                info: "info";
-                error: "error";
-                warning: "warning";
-            }>;
-            message: z.ZodString;
-            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                registrar: "registrar";
-                wpcloud: "wpcloud";
-                dns: "dns";
-                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>>>;
-        archive: z.ZodOptional<z.ZodObject<{
-            contentType: z.ZodLiteral<"application/zip">;
-            downloadUrl: z.ZodString;
-            expiresAt: z.ZodString;
-            sizeBytes: z.ZodOptional<z.ZodNumber>;
-            sha256: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        operationId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodString;
-        updatedAt: z.ZodString;
-    }, z.core.$strip>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-        hasMore: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const spaceImportSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"upload">;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"url">;
-    url: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"export">;
-    exportId: z.ZodString;
-}, z.core.$strip>], "kind">;
-export declare const spaceImportRequestSchema: z.ZodObject<{
-    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"upload">;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"url">;
-        url: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"export">;
-        exportId: z.ZodString;
-    }, z.core.$strip>], "kind">;
-    publish: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const spaceImportSchema: z.ZodObject<{
-    id: z.ZodString;
-    targetSpaceId: z.ZodString;
-    status: z.ZodEnum<{
-        failed: "failed";
-        canceled: "canceled";
-        created: "created";
-        ready: "ready";
-        waiting_for_archive: "waiting_for_archive";
-        validating: "validating";
-        materializing: "materializing";
-    }>;
-    archiveUpload: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        mode: z.ZodEnum<{
-            source: "source";
-            dist: "dist";
-        }>;
-        expiresAt: z.ZodString;
-        summary: z.ZodObject<{
-            upload: z.ZodNumber;
-            reused: z.ZodNumber;
-            ignored: z.ZodNumber;
-        }, z.core.$strip>;
-        targets: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            method: z.ZodEnum<{
-                POST: "POST";
-                PUT: "PUT";
-            }>;
-            url: z.ZodUnion<[z.ZodString, z.ZodString]>;
-            headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-            body: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"url">;
-                url: z.ZodString;
-            }, z.core.$strip>], "kind">>;
-            size: z.ZodOptional<z.ZodNumber>;
-            maxBytes: z.ZodOptional<z.ZodNumber>;
-            sha256: z.ZodOptional<z.ZodString>;
-            contentType: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>;
-        links: z.ZodObject<{
-            resume: z.ZodString;
-            finalize: z.ZodString;
-        }, z.core.$strip>;
-        details: z.ZodOptional<z.ZodObject<{
-            reused: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                reason: z.ZodString;
-            }, z.core.$strip>>>;
-            ignored: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                reason: z.ZodString;
-            }, z.core.$strip>>>;
-            diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                code: z.ZodString;
-                severity: z.ZodEnum<{
-                    info: "info";
-                    error: "error";
-                    warning: "warning";
-                }>;
-                message: z.ZodString;
-                path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                    registrar: "registrar";
-                    wpcloud: "wpcloud";
-                    dns: "dns";
-                    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>>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    draftVersionIds: z.ZodArray<z.ZodString>;
-    diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        severity: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            warning: "warning";
-        }>;
-        message: z.ZodString;
-        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            registrar: "registrar";
-            wpcloud: "wpcloud";
-            dns: "dns";
-            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>>>;
-    operationId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-export declare const spaceImportListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        targetSpaceId: z.ZodString;
-        status: z.ZodEnum<{
-            failed: "failed";
-            canceled: "canceled";
-            created: "created";
-            ready: "ready";
-            waiting_for_archive: "waiting_for_archive";
-            validating: "validating";
-            materializing: "materializing";
-        }>;
-        archiveUpload: z.ZodOptional<z.ZodObject<{
-            id: z.ZodString;
-            mode: z.ZodEnum<{
-                source: "source";
-                dist: "dist";
-            }>;
-            expiresAt: z.ZodString;
-            summary: z.ZodObject<{
-                upload: z.ZodNumber;
-                reused: z.ZodNumber;
-                ignored: z.ZodNumber;
-            }, z.core.$strip>;
-            targets: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                method: z.ZodEnum<{
-                    POST: "POST";
-                    PUT: "PUT";
-                }>;
-                url: z.ZodUnion<[z.ZodString, z.ZodString]>;
-                headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
-                body: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"url">;
-                    url: z.ZodString;
-                }, z.core.$strip>], "kind">>;
-                size: z.ZodOptional<z.ZodNumber>;
-                maxBytes: z.ZodOptional<z.ZodNumber>;
-                sha256: z.ZodOptional<z.ZodString>;
-                contentType: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            links: z.ZodObject<{
-                resume: z.ZodString;
-                finalize: z.ZodString;
-            }, z.core.$strip>;
-            details: z.ZodOptional<z.ZodObject<{
-                reused: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    path: z.ZodString;
-                    reason: z.ZodString;
-                }, z.core.$strip>>>;
-                ignored: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    path: z.ZodString;
-                    reason: z.ZodString;
-                }, z.core.$strip>>>;
-                diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    code: z.ZodString;
-                    severity: z.ZodEnum<{
-                        info: "info";
-                        error: "error";
-                        warning: "warning";
-                    }>;
-                    message: z.ZodString;
-                    path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                        registrar: "registrar";
-                        wpcloud: "wpcloud";
-                        dns: "dns";
-                        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>>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        draftVersionIds: z.ZodArray<z.ZodString>;
-        diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            code: z.ZodString;
-            severity: z.ZodEnum<{
-                info: "info";
-                error: "error";
-                warning: "warning";
-            }>;
-            message: z.ZodString;
-            path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                registrar: "registrar";
-                wpcloud: "wpcloud";
-                dns: "dns";
-                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>>>;
-        operationId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodString;
-        updatedAt: z.ZodString;
-    }, z.core.$strip>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-        hasMore: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type SpaceExport = z.infer<typeof spaceExportSchema>;
-export type SpaceImport = z.infer<typeof spaceImportSchema>;