@spacefast/common 0.0.5 → 0.0.7

package/dist/contracts/publishes.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export declare const publishStates: readonly ["awaiting_upload", "uploaded", "parked", "materializing", "succeeded", "failed", "cancelled", "expired"];
+export declare const publishStateSchema: z.ZodEnum<{
+    failed: "failed";
+    expired: "expired";
+    uploaded: "uploaded";
+    succeeded: "succeeded";
+    materializing: "materializing";
+    awaiting_upload: "awaiting_upload";
+    parked: "parked";
+    cancelled: "cancelled";
+}>;
+export type PublishState = z.infer<typeof publishStateSchema>;
+export declare const publishIdSchema: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+export declare const publishAdmissionSchema: z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    idempotencyKey: z.ZodString;
+    requestFingerprint: z.ZodString;
+}, z.core.$strip>;
+export declare const publishSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"awaiting_upload">;
+    target: z.ZodOptional<z.ZodObject<{
+        spaceId: z.ZodCustom<`spc_${string}`, `spc_${string}`>;
+        baseVersionId: z.ZodNullable<z.ZodCustom<`ver_${string}`, `ver_${string}`>>;
+    }, z.core.$strip>>;
+    counts: z.ZodOptional<z.ZodObject<{
+        received: z.ZodNumber;
+        missing: z.ZodNumber;
+    }, z.core.$strip>>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    upload: z.ZodOptional<z.ZodObject<{
+        missing: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodNullable<z.ZodString>;
+            size: z.ZodNumber;
+            url: z.ZodString;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            expiresAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"uploaded">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"parked">;
+    reason: z.ZodLiteral<"capacity">;
+    queuePosition: z.ZodOptional<z.ZodNumber>;
+    nextCheckAfterSeconds: z.ZodNumber;
+    actions: z.ZodTuple<[z.ZodObject<{
+        kind: z.ZodLiteral<"cancel_publish">;
+        publishId: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"materializing">;
+    operation: z.ZodObject<{
+        id: z.ZodCustom<`op_${string}`, `op_${string}`>;
+        kind: z.ZodLiteral<"publish.finalize">;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"succeeded">;
+    outcome: z.ZodEnum<{
+        created: "created";
+        unchanged: "unchanged";
+        updated: "updated";
+    }>;
+    capturedBaseVersionId: z.ZodOptional<z.ZodNullable<z.ZodCustom<`ver_${string}`, `ver_${string}`>>>;
+    result: z.ZodObject<{
+        space: z.ZodObject<{
+            id: z.ZodCustom<`spc_${string}`, `spc_${string}`>;
+            liveUrl: z.ZodString;
+        }, z.core.$strip>;
+        version: z.ZodObject<{
+            id: z.ZodCustom<`ver_${string}`, `ver_${string}`>;
+            immutableUrl: z.ZodString;
+        }, z.core.$strip>;
+        live: z.ZodObject<{
+            previousVersionId: z.ZodNullable<z.ZodCustom<`ver_${string}`, `ver_${string}`>>;
+            versionId: z.ZodCustom<`ver_${string}`, `ver_${string}`>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"failed">;
+    errorCode: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodCustom<`pub_${string}`, `pub_${string}`>;
+    state: z.ZodLiteral<"expired">;
+}, z.core.$strip>], "state">;
+export type Publish = z.infer<typeof publishSchema>;
+export type PublishAdmission = z.infer<typeof publishAdmissionSchema>;
+export type DurablePublish = Publish & PublishAdmission;
+export type PublishByState<State extends PublishState> = Extract<DurablePublish, {
+    state: State;
+}>;
+declare const allowedTransitions: {
+    readonly awaiting_upload: readonly ["uploaded", "cancelled", "expired"];
+    readonly uploaded: readonly ["parked", "materializing", "cancelled", "expired"];
+    readonly parked: readonly ["materializing", "cancelled", "expired"];
+    readonly materializing: readonly ["succeeded", "failed", "cancelled", "expired"];
+    readonly succeeded: readonly [];
+    readonly failed: readonly [];
+    readonly cancelled: readonly [];
+    readonly expired: readonly [];
+};
+export type NextPublishState<State extends PublishState> = (typeof allowedTransitions)[State][number];
+export declare function canTransitionPublish<From extends PublishState>(from: From, to: PublishState): to is NextPublishState<From>;
+export declare function transitionPublish<From extends PublishState, Next extends DurablePublish>(publish: PublishByState<From>, next: Next & (Next["state"] extends NextPublishState<From> ? unknown : never)): Next;
+export type PublishAdmissionResult<Existing extends PublishAdmission = PublishAdmission> = {
+    outcome: "created";
+    publish: PublishAdmission;
+} | {
+    outcome: "replayed";
+    publish: Existing;
+} | {
+    outcome: "conflict";
+    publish: Existing;
+};
+export declare function convergePublishAdmission<Existing extends PublishAdmission>(existing: Existing | undefined, attempted: PublishAdmission): PublishAdmissionResult<Existing>;
+export {};

package/dist/contracts/publishes.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { registeredIdSchema } from "./ids.js";
+export const publishStates = [
+    "awaiting_upload",
+    "uploaded",
+    "parked",
+    "materializing",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "expired",
+];
+export const publishStateSchema = z.enum(publishStates);
+export const publishIdSchema = registeredIdSchema("pub");
+const spaceIdSchema = registeredIdSchema("spc");
+const versionIdSchema = registeredIdSchema("ver");
+export const publishAdmissionSchema = z.object({
+    id: publishIdSchema,
+    idempotencyKey: z.string().min(1),
+    requestFingerprint: z.string().min(1),
+});
+const cancellableActionSchema = z.object({
+    kind: z.literal("cancel_publish"),
+    publishId: publishIdSchema,
+});
+export const publishSchema = z.discriminatedUnion("state", [
+    z.object({
+        id: publishIdSchema,
+        state: z.literal("awaiting_upload"),
+        target: z
+            .object({
+            spaceId: spaceIdSchema,
+            baseVersionId: versionIdSchema.nullable(),
+        })
+            .optional(),
+        counts: z
+            .object({
+            received: z.number().int().nonnegative(),
+            missing: z.number().int().positive(),
+        })
+            .optional(),
+        expiresAt: z.string().datetime().optional(),
+        upload: z.object({
+            missing: z.array(z.object({
+                path: z.string(),
+                sha256: z.string().regex(/^[0-9a-f]{64}$/).nullable(),
+                size: z.number().int().nonnegative(),
+                url: z.string().url(),
+                headers: z.record(z.string(), z.string()),
+                expiresAt: z.string().datetime(),
+            })).min(1),
+        }).optional(),
+    }).refine((publish) => publish.counts === undefined ||
+        publish.upload === undefined ||
+        publish.counts.missing === publish.upload.missing.length, {
+        message: "Upload instructions must match the missing upload count.",
+        path: ["upload", "missing"],
+    }).refine((publish) => publish.counts !== undefined || publish.upload !== undefined, {
+        message: "An awaiting_upload publish must carry counts or upload instructions.",
+        path: ["counts"],
+    }),
+    z.object({ id: publishIdSchema, state: z.literal("uploaded") }),
+    z
+        .object({
+        id: publishIdSchema,
+        state: z.literal("parked"),
+        reason: z.literal("capacity"),
+        queuePosition: z.number().int().positive().optional(),
+        nextCheckAfterSeconds: z.number().int().positive(),
+        actions: z.tuple([cancellableActionSchema]),
+    })
+        .refine((publish) => publish.actions.every((action) => action.publishId === publish.id), {
+        message: "Cancel actions must reference the enclosing publish.",
+        path: ["actions"],
+    }),
+    z.object({
+        id: publishIdSchema,
+        state: z.literal("materializing"),
+        operation: z.object({
+            id: registeredIdSchema("op"),
+            kind: z.literal("publish.finalize"),
+            status: z.enum(["queued", "running"]),
+        }),
+    }),
+    z.object({
+        id: publishIdSchema,
+        state: z.literal("succeeded"),
+        outcome: z.enum(["created", "updated", "unchanged"]),
+        capturedBaseVersionId: versionIdSchema.nullable().optional(),
+        result: z.object({
+            space: z.object({ id: spaceIdSchema, liveUrl: z.string().url() }),
+            version: z.object({ id: versionIdSchema, immutableUrl: z.string().url() }),
+            live: z.object({
+                previousVersionId: versionIdSchema.nullable(),
+                versionId: versionIdSchema,
+            }),
+        }),
+    }),
+    z.object({ id: publishIdSchema, state: z.literal("failed"), errorCode: z.string().min(1) }),
+    z.object({ id: publishIdSchema, state: z.literal("cancelled") }),
+    z.object({ id: publishIdSchema, state: z.literal("expired") }),
+]);
+// Cancellation may win during materialization only before the Version exists;
+// afterwards it is not cancelable and the outcome is unchanged.
+const allowedTransitions = {
+    awaiting_upload: ["uploaded", "cancelled", "expired"],
+    uploaded: ["parked", "materializing", "cancelled", "expired"],
+    parked: ["materializing", "cancelled", "expired"],
+    materializing: ["succeeded", "failed", "cancelled", "expired"],
+    succeeded: [],
+    failed: [],
+    cancelled: [],
+    expired: [],
+};
+export function canTransitionPublish(from, to) {
+    return allowedTransitions[from].some((candidate) => candidate === to);
+}
+export function transitionPublish(publish, next) {
+    if (publish.id !== next.id ||
+        publish.idempotencyKey !== next.idempotencyKey ||
+        publish.requestFingerprint !== next.requestFingerprint) {
+        throw new Error("A publish transition cannot change the durable publish identity.");
+    }
+    if (!canTransitionPublish(publish.state, next.state)) {
+        throw new Error(`Invalid publish transition: ${publish.state} -> ${next.state}`);
+    }
+    // Project through the wire schema so fields from the previous variant (e.g. a
+    // parked `reason` spread into a materializing publish) never leak downstream.
+    return {
+        ...publishSchema.parse(next),
+        idempotencyKey: next.idempotencyKey,
+        requestFingerprint: next.requestFingerprint,
+    };
+}
+export function convergePublishAdmission(existing, attempted) {
+    if (existing === undefined)
+        return { outcome: "created", publish: attempted };
+    if (existing.idempotencyKey !== attempted.idempotencyKey) {
+        throw new Error("Admission convergence requires one idempotency key.");
+    }
+    if (existing.requestFingerprint !== attempted.requestFingerprint) {
+        return { outcome: "conflict", publish: existing };
+    }
+    return { outcome: "replayed", publish: existing };
+}

package/dist/contracts/push-new.d.ts

@@ -4,9 +4,9 @@ export declare const pushNewSessionStatusSchema: z.ZodEnum<{
     failed: "failed";
     expired: "expired";
     building: "building";
+    publishing: "publishing";
     waiting_for_push: "waiting_for_push";
     waiting_for_upload: "waiting_for_upload";
-    publishing: "publishing";
 }>;
 export declare const pushNewSourceKindSchema: z.ZodEnum<{
     direct_upload: "direct_upload";
@@ -23,9 +23,9 @@ export declare const PushNewSessionSchema: z.ZodObject<{
         failed: "failed";
         expired: "expired";
         building: "building";
+        publishing: "publishing";
         waiting_for_push: "waiting_for_push";
         waiting_for_upload: "waiting_for_upload";
-        publishing: "publishing";
     }>;
     sourceKind: z.ZodEnum<{
         direct_upload: "direct_upload";
@@ -68,9 +68,9 @@ export declare const PushNewCreateSessionResponseSchema: z.ZodObject<{
         failed: "failed";
         expired: "expired";
         building: "building";
+        publishing: "publishing";
         waiting_for_push: "waiting_for_push";
         waiting_for_upload: "waiting_for_upload";
-        publishing: "publishing";
     }>;
     sourceKind: z.ZodEnum<{
         direct_upload: "direct_upload";
@@ -113,9 +113,9 @@ export declare const PushNewStatusResponseSchema: z.ZodObject<{
         failed: "failed";
         expired: "expired";
         building: "building";
+        publishing: "publishing";
         waiting_for_push: "waiting_for_push";
         waiting_for_upload: "waiting_for_upload";
-        publishing: "publishing";
     }>;
     expiresAt: z.ZodString;
     createdAt: z.ZodString;

package/dist/contracts/quotas.d.ts

@@ -10,7 +10,9 @@ export declare const WORST_CASE_QUOTAS: {
 export type WorstCaseQuotaName = keyof typeof WORST_CASE_QUOTAS;
 export declare const ANONYMOUS_PUBLISH_CAPS: {
     readonly maxFileBytes: number;
+    readonly maxTotalBytes: number;
     readonly maxInlineBodyBytes: number;
     readonly maxFilesPerVersion: 1000;
     readonly maxPublishesPerIpPerHour: 20;
+    readonly maxLifetimeViews: 100;
 };

package/dist/contracts/quotas.js

@@ -26,6 +26,9 @@ export const WORST_CASE_QUOTAS = {
 export const ANONYMOUS_PUBLISH_CAPS = {
     // Per-file ceiling (= Free plan maxFileBytes).
     maxFileBytes: 50 * 1024 * 1024,
+    // Per-version total ceiling (sum of file bytes). Matches the inline body
+    // cap so the two publish encodings agree on how big an anonymous site can be.
+    maxTotalBytes: 100 * 1024 * 1024,
     // Inline one-shot publish body cap; tighter than the absolute
     // maxInlinePublishBodyBytes ceiling above.
     maxInlineBodyBytes: 100 * 1024 * 1024,
@@ -33,4 +36,9 @@ export const ANONYMOUS_PUBLISH_CAPS = {
     maxFilesPerVersion: 1000,
     // Anonymous publish/space-create attempts per IP per hour.
     maxPublishesPerIpPerHour: WORST_CASE_QUOTAS.maxPublishesPerIpPerHour,
+    // Views (non-crawler, status<400 requests) an unclaimed space may serve over
+    // its whole claim window before it goes dark behind the claim-nudge
+    // tombstone. Enforced by the periodic visit-quota sweep, so it is
+    // deliberately approximate — claiming the space lifts it entirely.
+    maxLifetimeViews: 100,
 };

package/dist/contracts/repository-connections.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 export declare const repositoryConnectionTypeSchema: z.ZodEnum<{
-    connected: "connected";
     hosted: "hosted";
+    connected: "connected";
 }>;
 export declare const repositoryConnectionSyncStatusSchema: z.ZodEnum<{
     failed: "failed";
@@ -19,10 +19,13 @@ export declare const RepositoryConnectionSchema: z.ZodObject<{
         generic: "generic";
     }>;
     connectionType: z.ZodEnum<{
-        connected: "connected";
         hosted: "hosted";
+        connected: "connected";
     }>;
     repositoryId: z.ZodNullable<z.ZodString>;
+    installationId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    cloneUrlConfigured: z.ZodDefault<z.ZodBoolean>;
+    upstreamUrlConfigured: z.ZodDefault<z.ZodBoolean>;
     repositoryName: z.ZodString;
     repositoryFullName: z.ZodString;
     defaultBranch: z.ZodString;
@@ -63,8 +66,8 @@ export declare const repositoryConnectionCreateSchema: z.ZodObject<{
         generic: "generic";
     }>>;
     connectionType: z.ZodDefault<z.ZodEnum<{
-        connected: "connected";
         hosted: "hosted";
+        connected: "connected";
     }>>;
     repositoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     repositoryName: z.ZodOptional<z.ZodString>;
@@ -92,8 +95,8 @@ export declare const repositoryConnectionCreateSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const repositoryConnectionPatchSchema: z.ZodObject<{
     connectionType: z.ZodOptional<z.ZodEnum<{
-        connected: "connected";
         hosted: "hosted";
+        connected: "connected";
     }>>;
     productionBranch: z.ZodOptional<z.ZodString>;
     cloneUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -122,6 +125,7 @@ export declare const repositoryImportRemoteSchema: z.ZodObject<{
         generic: "generic";
     }>>;
     repositoryFullName: z.ZodString;
+    credential: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     repositoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     repositoryName: z.ZodOptional<z.ZodString>;
     defaultBranch: z.ZodDefault<z.ZodString>;
@@ -141,7 +145,6 @@ export declare const repositoryImportRemoteSchema: z.ZodObject<{
     }, z.core.$strip>>;
     autoDeployProduction: z.ZodDefault<z.ZodBoolean>;
     autoDeployPreviews: z.ZodDefault<z.ZodBoolean>;
-    credential: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     installationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     upstreamUrl: z.ZodString;
 }, z.core.$strip>;
@@ -181,8 +184,8 @@ export declare const repositoryWebhookDeliveryListQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     cursor: z.ZodOptional<z.ZodString>;
     connectionType: z.ZodOptional<z.ZodEnum<{
-        connected: "connected";
         hosted: "hosted";
+        connected: "connected";
     }>>;
     status: z.ZodOptional<z.ZodEnum<{
         failed: "failed";
@@ -224,8 +227,6 @@ export declare const repositoryWebhookDeliveryListResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type RepositoryConnection = z.infer<typeof RepositoryConnectionSchema>;
-export type RepositoryConnectionCreate = z.infer<typeof repositoryConnectionCreateSchema>;
-export type RepositoryConnectionPatch = z.infer<typeof repositoryConnectionPatchSchema>;
 export type RepositoryImportRemote = z.infer<typeof repositoryImportRemoteSchema>;
 export type RepositoryConnectionType = z.infer<typeof repositoryConnectionTypeSchema>;
 export type RepositoryWebhookDelivery = z.infer<typeof RepositoryWebhookDeliverySchema>;

package/dist/contracts/repository-connections.js

@@ -15,6 +15,19 @@ export const RepositoryConnectionSchema = z.object({
     provider: gitProvider.describe("Git host family for the repository connection."),
     connectionType: repositoryConnectionTypeSchema,
     repositoryId: z.string().nullable(),
+    installationId: z
+        .string()
+        .nullable()
+        .default(null)
+        .describe("Repository app installation id, when configured."),
+    cloneUrlConfigured: z
+        .boolean()
+        .default(false)
+        .describe("Whether a repository clone URL is configured."),
+    upstreamUrlConfigured: z
+        .boolean()
+        .default(false)
+        .describe("Whether an upstream repository URL is configured."),
     repositoryName: z.string(),
     repositoryFullName: z.string(),
     defaultBranch: z.string(),

package/dist/contracts/resources.d.ts

@@ -38,6 +38,7 @@ export declare const ChannelPointerSchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, z.core.$strip>;
 export type ChannelPointer = z.infer<typeof ChannelPointerSchema>;
+export declare const spaceSettingsDigestSchema: z.ZodString;
 export declare const SpaceSchema: z.ZodObject<{
     id: z.ZodString;
     tenantId: z.ZodString;
@@ -70,6 +71,7 @@ export declare const SpaceSchema: z.ZodObject<{
             abuse_takedown: "abuse_takedown";
             tenant_suspended: "tenant_suspended";
             site_suspended: "site_suspended";
+            visit_cap_exceeded: "visit_cap_exceeded";
         }>;
     }, z.core.$strip>>;
     claimState: z.ZodNullable<z.ZodObject<{
@@ -83,7 +85,31 @@ export declare const SpaceSchema: z.ZodObject<{
     defaultHostname: z.ZodString;
     publicName: z.ZodString;
     liveUrl: z.ZodString;
+    thumbnail: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            image: "image";
+            screenshot: "screenshot";
+        }>;
+        provider: z.ZodEnum<{
+            "wpcom-mshots": "wpcom-mshots";
+            "wpcom-site-accelerator": "wpcom-site-accelerator";
+        }>;
+        url: z.ZodString;
+        sourceUrl: z.ZodString;
+    }, z.core.$strip>>;
     dataLocation: z.ZodString;
+    region: z.ZodString;
+    placementMode: z.ZodEnum<{
+        shared: "shared";
+        dedicated: "dedicated";
+    }>;
+    burstable: z.ZodNullable<z.ZodBoolean>;
+    archivedBytes: z.ZodNumber;
+    tierPolicy: z.ZodEnum<{
+        auto: "auto";
+        always_hot: "always_hot";
+    }>;
+    moving: z.ZodBoolean;
     channels: z.ZodRecord<z.ZodString, z.ZodObject<{
         versionId: z.ZodOptional<z.ZodString>;
         weighted: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -98,6 +124,7 @@ export declare const SpaceSchema: z.ZodObject<{
             path: z.ZodString;
             status: z.ZodNumber;
         }, z.core.$strip>]>>;
+        cleanUrls: z.ZodOptional<z.ZodBoolean>;
         listing: z.ZodOptional<z.ZodBoolean>;
         meta: z.ZodOptional<z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
@@ -130,6 +157,7 @@ export declare const SpaceSchema: z.ZodObject<{
                         reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>>>;
                 }, z.core.$strip>>;
+                requireReview: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         templates: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -156,6 +184,15 @@ export declare const SpaceSchema: z.ZodObject<{
                 }, z.core.$strip>>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        pages: z.ZodOptional<z.ZodObject<{
+            theme: z.ZodOptional<z.ZodObject<{
+                accent: z.ZodOptional<z.ZodString>;
+                background: z.ZodOptional<z.ZodString>;
+                logo: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                fontFamily: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         build: z.ZodOptional<z.ZodObject<{
             rootDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             installDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -168,6 +205,15 @@ export declare const SpaceSchema: z.ZodObject<{
             allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodBoolean>;
             timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
+        placement: z.ZodOptional<z.ZodObject<{
+            region: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                shared: "shared";
+                dedicated: "dedicated";
+            }>>;
+            burstable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        markdownNegotiation: z.ZodOptional<z.ZodBoolean>;
         experimental_gutenberg: z.ZodOptional<z.ZodBoolean>;
         inject: z.ZodOptional<z.ZodObject<{
             head: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -176,11 +222,15 @@ export declare const SpaceSchema: z.ZodObject<{
             noscript: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    settingsDigest: z.ZodString;
     noindex: z.ZodBoolean;
     policy: z.ZodNullable<z.ZodObject<{
         rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
             match: z.ZodDefault<z.ZodObject<{
                 host: z.ZodOptional<z.ZodString>;
+                hostPattern: z.ZodOptional<z.ZodString>;
+                hostTemplate: z.ZodOptional<z.ZodString>;
                 pathPattern: z.ZodOptional<z.ZodString>;
                 channel: z.ZodOptional<z.ZodString>;
                 ipCidrs: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -197,29 +247,45 @@ export declare const SpaceSchema: z.ZodObject<{
                 challenge: "challenge";
             }>;
             auth: z.ZodOptional<z.ZodObject<{
-                password: z.ZodOptional<z.ZodObject<{
+                requiredGrants: z.ZodArray<z.ZodString>;
+                issuers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    kid: z.ZodString;
+                    alg: z.ZodLiteral<"EdDSA">;
+                    publicKey: z.ZodString;
+                    grantNamespaces: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>>;
+                acquire: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"password">;
                     ref: z.ZodString;
                     transport: z.ZodEnum<{
                         basic: "basic";
                         form: "form";
                     }>;
                     username: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
-                token: z.ZodOptional<z.ZodObject<{
-                    requiredGrants: z.ZodArray<z.ZodString>;
-                    issuers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        kid: z.ZodString;
-                        alg: z.ZodLiteral<"EdDSA">;
-                        publicKey: z.ZodString;
-                        grantNamespaces: z.ZodArray<z.ZodString>;
-                    }, z.core.$strip>>>;
-                    loginUrl: z.ZodOptional<z.ZodString>;
-                    cookieName: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"login">;
+                    url: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>], "type">>>;
             }, z.core.$strip>>;
+            managedBy: z.ZodOptional<z.ZodEnum<{
+                sharing: "sharing";
+                firewall: "firewall";
+                file_share: "file_share";
+                cast_reviewer: "cast_reviewer";
+                team_default: "team_default";
+            }>>;
+            expiresAt: z.ZodOptional<z.ZodNumber>;
             reasonCode: z.ZodOptional<z.ZodString>;
             message: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        issuers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kid: z.ZodString;
+            alg: z.ZodLiteral<"EdDSA">;
+            publicKey: z.ZodString;
+            grantNamespaces: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        sessionVersion: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     operation: z.ZodNullable<z.ZodObject<{
         id: z.ZodString;
@@ -373,6 +439,7 @@ export declare const VersionSchema: z.ZodObject<{
             path: z.ZodString;
             status: z.ZodNumber;
         }, z.core.$strip>]>>;
+        cleanUrls: z.ZodOptional<z.ZodBoolean>;
         listing: z.ZodOptional<z.ZodBoolean>;
         meta: z.ZodOptional<z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
@@ -405,6 +472,7 @@ export declare const VersionSchema: z.ZodObject<{
                         reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                     }, z.core.$strip>>>;
                 }, z.core.$strip>>;
+                requireReview: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         templates: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -431,6 +499,15 @@ export declare const VersionSchema: z.ZodObject<{
                 }, z.core.$strip>>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        pages: z.ZodOptional<z.ZodObject<{
+            theme: z.ZodOptional<z.ZodObject<{
+                accent: z.ZodOptional<z.ZodString>;
+                background: z.ZodOptional<z.ZodString>;
+                logo: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                fontFamily: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         build: z.ZodOptional<z.ZodObject<{
             rootDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             installDirectory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -443,6 +520,15 @@ export declare const VersionSchema: z.ZodObject<{
             allowUnsupportedPlatformFeatures: z.ZodOptional<z.ZodBoolean>;
             timeoutSeconds: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
+        placement: z.ZodOptional<z.ZodObject<{
+            region: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                shared: "shared";
+                dedicated: "dedicated";
+            }>>;
+            burstable: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        markdownNegotiation: z.ZodOptional<z.ZodBoolean>;
         experimental_gutenberg: z.ZodOptional<z.ZodBoolean>;
         inject: z.ZodOptional<z.ZodObject<{
             head: z.ZodOptional<z.ZodArray<z.ZodString>>;