@spacefast/common 0.0.23 → 0.0.24

package/dist/contracts/usage.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/**
+ * Resolutions the hosting provider keeps usage at. Hour is retained about a
+ * week, day about two months, month about two years.
+ */
+export declare const USAGE_RESOLUTIONS: readonly ["hour", "day", "month"];
+export type UsageResolution = (typeof USAGE_RESOLUTIONS)[number];
+export declare const usageResolutionSchema: z.ZodEnum<{
+    day: "day";
+    hour: "hour";
+    month: "month";
+}>;
+export declare const spaceUsageMeasurementSchema: z.ZodObject<{
+    period: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        resolution: z.ZodEnum<{
+            day: "day";
+            hour: "hour";
+            month: "month";
+        }>;
+    }, z.core.$strip>;
+    sampledAt: z.ZodString;
+    storageBytes: z.ZodNumber;
+    computeSeconds: z.ZodNumber;
+    bandwidthBytes: z.ZodNumber;
+    emailCount: z.ZodNumber;
+    functionInvocations: z.ZodNumber;
+    functionErrors: z.ZodNumber;
+}, z.core.$strip>;
+export declare const spaceUsageResponseSchema: z.ZodObject<{
+    spaceId: z.ZodString;
+    usage: z.ZodNullable<z.ZodObject<{
+        period: z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+            resolution: z.ZodEnum<{
+                day: "day";
+                hour: "hour";
+                month: "month";
+            }>;
+        }, z.core.$strip>;
+        sampledAt: z.ZodString;
+        storageBytes: z.ZodNumber;
+        computeSeconds: z.ZodNumber;
+        bandwidthBytes: z.ZodNumber;
+        emailCount: z.ZodNumber;
+        functionInvocations: z.ZodNumber;
+        functionErrors: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SpaceUsageMeasurement = z.infer<typeof spaceUsageMeasurementSchema>;
+export type SpaceUsageResponse = z.infer<typeof spaceUsageResponseSchema>;
+export declare const functionUsagePushSchema: z.ZodObject<{
+    spaceId: z.ZodString;
+    versionId: z.ZodString;
+    invocations: z.ZodNumber;
+    errors: z.ZodNumber;
+    observedAt: z.ZodString;
+}, z.core.$strip>;
+export type FunctionUsagePush = z.infer<typeof functionUsagePushSchema>;

package/dist/contracts/usage.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+/**
+ * Resolutions the hosting provider keeps usage at. Hour is retained about a
+ * week, day about two months, month about two years.
+ */
+export const USAGE_RESOLUTIONS = ["hour", "day", "month"];
+export const usageResolutionSchema = z.enum(USAGE_RESOLUTIONS);
+// Served by `GET /v1/spaces/{spaceId}/usage`: what one Space actually consumed,
+// measured by the infrastructure that served it rather than derived from what
+// was published.
+//
+// Every number here is a MEASUREMENT OF A PAST PERIOD, not a live gauge, and the
+// contract says so out loud: `period` is the window measured and `sampledAt` is
+// when we last asked. Nothing in this response means "right now". The meter
+// behind it is a time series with real ingestion delay, so a reading is only
+// trusted once its period has settled — expect the period to end an hour or so
+// before you read it.
+export const spaceUsageMeasurementSchema = z.object({
+    period: z
+        .object({
+        start: z.string().describe("First instant of the measured period."),
+        end: z
+            .string()
+            .describe("Last instant of the measured period. The numbers are current as of here."),
+        resolution: usageResolutionSchema.describe("Length of the measured period."),
+    })
+        .describe("The window these numbers describe."),
+    sampledAt: z
+        .string()
+        .describe("When the platform last read this space's usage from the serving infrastructure."),
+    storageBytes: z
+        .number()
+        .describe("Average bytes of disk the space occupied during the period. This is what storage is billed on: bytes actually on disk, not the size of what was uploaded."),
+    computeSeconds: z.number().describe("Seconds of compute the space consumed during the period."),
+    bandwidthBytes: z.number().describe("Bytes the space served during the period."),
+    emailCount: z.number().int().describe("Emails the space sent during the period."),
+    functionInvocations: z
+        .number()
+        .int()
+        .describe("Function invocations during the period, counted where the space is known. Best-effort: counts are pushed after each request completes and may arrive late."),
+    functionErrors: z
+        .number()
+        .int()
+        .describe("Function invocations during the period that ended in an error."),
+});
+export const spaceUsageResponseSchema = z.object({
+    spaceId: z.string().describe("The space the usage was measured for."),
+    usage: spaceUsageMeasurementSchema
+        .nullable()
+        .describe("Null when this space has never been measured — a space that has not served yet, or one whose first measurement period has not settled."),
+});
+// Posted by the Functions host's tail Worker after an isolate finishes serving.
+// Counts only — never messages. Function LOGS travel a different path, into the
+// space's own log stream, and merging the two would quietly turn this into a
+// second log pipeline.
+export const functionUsagePushSchema = z.object({
+    spaceId: z.string().min(1).describe("The space whose functions ran."),
+    versionId: z.string().min(1).describe("The version whose bundle served the requests."),
+    invocations: z.number().int().nonnegative().describe("Requests the isolate served."),
+    errors: z.number().int().nonnegative().describe("Those requests that ended in an error."),
+    observedAt: z
+        .string()
+        .describe("The reporter's clock at delivery. The control plane buckets by hour on receipt."),
+});

package/dist/contracts/variables.d.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 export declare const variableScope: z.ZodEnum<{
-    site: "site";
     space: "space";
     principal: "principal";
 }>;
@@ -8,7 +7,6 @@ export declare const variableNameSchema: z.ZodString;
 export declare const VariableSchema: z.ZodObject<{
     name: z.ZodString;
     scope: z.ZodEnum<{
-        site: "site";
         space: "space";
         principal: "principal";
     }>;
@@ -47,7 +45,6 @@ export declare const variableListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         scope: z.ZodEnum<{
-            site: "site";
             space: "space";
             principal: "principal";
         }>;
@@ -66,7 +63,6 @@ export declare const spaceVariableListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
         scope: z.ZodEnum<{
-            site: "site";
             space: "space";
             principal: "principal";
         }>;
@@ -89,7 +85,6 @@ export declare const variableMutationResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         name: z.ZodString;
         scope: z.ZodEnum<{
-            site: "site";
             space: "space";
             principal: "principal";
         }>;
@@ -122,8 +117,8 @@ export declare const variableMutationResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                error: "error";
                 warning: "warning";
+                error: "error";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -166,8 +161,8 @@ export declare const variableDeleteResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                error: "error";
                 warning: "warning";
+                error: "error";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/contracts/variables.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { AsyncOperationSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
 // Variable (internal-docs/platform.md "Product Data Shapes"): one model for
-// every scope. Resolution order at finalize is space -> principal -> site.
-// Secret values are write-only after creation: never returned by API, CLI,
-// UI, diagnostics, logs, or activity.
-export const variableScope = z.enum(["space", "principal", "site"]);
+// every scope. Resolution order at finalize is space -> principal. A space IS
+// a site, so a space variable is the site variable — there is no third scope
+// underneath it. Secret values are write-only after creation: never returned
+// by API, CLI, UI, diagnostics, logs, or activity.
+export const variableScope = z.enum(["space", "principal"]);
 export const variableNameSchema = z
     .string()
     .min(1)
@@ -17,7 +18,7 @@ export const variableNameSchema = z
 });
 export const VariableSchema = z.object({
     name: variableNameSchema.describe("Variable name, referenced as {{ vars.NAME }} in templates."),
-    scope: variableScope.describe("Where the variable is defined; space wins over principal/site."),
+    scope: variableScope.describe("Where the variable is defined; space wins over principal."),
     secret: z.boolean().describe("Secret values are write-only and never returned after creation."),
     value: z.string().optional().describe("Variable value; omitted when secret=true."),
     channelValues: z

package/dist/contracts/webhooks.d.ts

@@ -94,8 +94,8 @@ export declare const webhookDeliverySchema: z.ZodObject<{
         code: z.ZodString;
         severity: z.ZodEnum<{
             info: "info";
-            error: "error";
             warning: "warning";
+            error: "error";
         }>;
         message: z.ZodString;
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -135,8 +135,8 @@ export declare const webhookDeliveryListResponseSchema: z.ZodObject<{
             code: z.ZodString;
             severity: z.ZodEnum<{
                 info: "info";
-                error: "error";
                 warning: "warning";
+                error: "error";
             }>;
             message: z.ZodString;
             path: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/contracts/zero.d.ts

@@ -12,6 +12,13 @@ import { type RuntimeRealtimeMode } from "./execution.js";
  * for the narrow surface both products can host.
  */
 export declare const ZERO_SOURCE_METADATA_KEY = "statticZero";
+/**
+ * The tag a compiled capsule artifact carries — in the finalize payload, the
+ * runtime config, the install profile, the client config the browser reads, and
+ * every realtime event — so PHP and the Rust runner can tell what they were
+ * handed. It is a property of the artifact the tree produced, not a kind a
+ * space declares: a publish can carry this beside a worker.
+ */
 export declare const ZERO_RUNTIME_KIND = "zero";
 export declare const ZERO_PLATFORM_ROUTE_PREFIX = "/__spacefast/zero";
 /**
@@ -37,9 +44,55 @@ export declare const ZERO_RUNTIME_CONFIG_PATH = "__spacefast/zero/config.json";
 export declare const ZERO_RUNTIME_BINARY_PATH = "__spacefast/zero/bin/stattic-runtime";
 export declare const ZERO_RUNTIME_BINARY_COMPATIBILITY_TARGET = "wpcloud-linux-x86_64-gnu-v1";
 export declare const ZERO_RUNTIME_BUNDLE_ROOT = "__spacefast/zero/bundles";
-export declare const ZERO_RUNTIME_CLIENT_BUNDLE_PATH = "__spacefast/zero/bundles/client.js";
 export declare const ZERO_RUNTIME_SERVER_BUNDLE_PATH = "__spacefast/zero/bundles/server.qjs.mjs";
-export declare const ZERO_RUNTIME_BUNDLE_MAX_BYTES = 786432;
+/** The compiled capsule client, served at the app root. */
+export declare const ZERO_PUBLIC_CLIENT_BUNDLE_PATH = "client.js";
+/**
+ * Where platform-owned client bytes serve from: same origin as the space, one
+ * content-addressed directory per platform build.
+ *
+ * Same origin is the whole point. Browsers have partitioned the HTTP cache by
+ * top-level site since 2020, so a shared third-party CDN buys nothing a
+ * same-origin URL does not — and costs a `script-src` hole. What a stable,
+ * content-addressed URL does buy is real: the digest changes only when the
+ * platform bytes change, so publishing a capsule a hundred times re-downloads
+ * the capsule's own bundle a hundred times and the platform's exactly once.
+ *
+ * Underscore-prefixed by framework convention (`_next/static`, `_astro`), which
+ * is also how the runtime recognises it as immutable — see `immutable_path` in
+ * `crates/stattic-runtime-core/src/finalize.rs`.
+ */
+export declare const ZERO_PLATFORM_ASSET_NAMESPACE = "_spacefast";
+export declare const ZERO_PLATFORM_ASSET_ROOT = "_spacefast/platform";
+/** The serving path of one file in the platform build identified by `digest`. */
+export declare function zeroPlatformAssetPath(digest: string, fileName: string): string;
+/**
+ * The compiled capsule server, which the QuickJS runner instantiates whole.
+ *
+ * 768 KiB is inherited, not measured: nobody has yet established what the
+ * runner actually tolerates, and DS77 keeps the number only until someone does.
+ * It binds a real resource — the runner holds the module graph in the site's
+ * PHP-worker memory before executing anything — so it stays low deliberately;
+ * server code is handlers, not an application.
+ */
+export declare const ZERO_SERVER_BUNDLE_MAX_BYTES = 786432;
+/**
+ * The tenant client bundle, and every other file the compile ships as content.
+ *
+ * This measures what the tenant publishes, and only that: the SDK, the kit, the
+ * chart layer, preact, recharts and lucide are externals resolved through the
+ * shell's import map to {@link ZERO_PLATFORM_ASSET_ROOT}, so platform bytes are
+ * never weighed here (DS42). What remains is author code plus whatever npm the
+ * author chose to bundle.
+ *
+ * 8 MiB matches the Functions per-entry cap (DS77) because the same reasoning
+ * applies: a client bundle is static bytes to a browser, so nothing on the
+ * serving side binds it, and the cap exists to fail an accidental
+ * hundred-megabyte dependency in our tooling — where the build can say which
+ * modules are large — rather than at upload. It is a guardrail, not a budget;
+ * the size report is what an author should be reading.
+ */
+export declare const ZERO_CLIENT_BUNDLE_MAX_BYTES: number;
 /**
  * A capsule's compiled server travels as version metadata, not as content, so a
  * server-only change leaves the published app shell byte-identical — and the
@@ -58,7 +111,7 @@ export declare const ZERO_MANAGED_TABLE_COLUMNS: readonly ["id", "createdAt", "u
  * router and auth flow already do.
  */
 export declare const ZERO_RESERVED_APP_ROUTE_PATHS: readonly ["/", "/index.html", "/client.js", "/auth/callback"];
-export declare const ZERO_RESERVED_APP_ROUTE_PREFIXES: readonly ["/auth/"];
+export declare const ZERO_RESERVED_APP_ROUTE_PREFIXES: readonly ["/auth/", "/_spacefast/"];
 export declare const zeroEndpointSchema: z.ZodObject<{
     method: z.ZodEnum<{
         POST: "POST";
@@ -129,10 +182,12 @@ export declare const zeroDatabaseSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
 }, z.core.$strict>>;
 export type ZeroDatabase = z.infer<typeof zeroDatabaseSchema>;
 /**
- * Zero's bundles travel inline in the finalize payload — a capsule's compiled
- * client and server fit comfortably under the ceiling, and inlining keeps the
+ * The compiled server travels inline in the finalize payload; inlining keeps the
  * whole version one atomic write. Functions bundles do the opposite and land
  * in the content store first; see `functionsBundleRefSchema`.
+ *
+ * The client never travels this way. It is content — the browser fetches it
+ * from the version tree like any other asset — so it ships as a static file.
  */
 export declare const zeroRuntimeBundleSchema: z.ZodObject<{
     path: z.ZodString;
@@ -160,6 +215,9 @@ export declare const zeroRuntimeRunSourceSchema: z.ZodObject<{
         env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -185,6 +243,9 @@ export declare const zeroRuntimeEndpointSourceSchema: z.ZodObject<{
         env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
     db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
@@ -754,6 +815,9 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
         db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
@@ -768,6 +832,9 @@ export declare const zeroRuntimeFinalizePayloadSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
         }, z.core.$strip>>;
         db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
@@ -872,6 +939,10 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
         signOutUrl: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         returnToParam: z.ZodDefault<z.ZodString>;
     }, z.core.$strict>>;
+    variables: z.ZodObject<{
+        source: z.ZodLiteral<"stattic-variables">;
+        names: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
     realtime: z.ZodObject<{
         mode: z.ZodEnum<{
             local: "local";
@@ -886,10 +957,6 @@ export declare const zeroRuntimeConfigSchema: z.ZodObject<{
             token: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>;
-    variables: z.ZodObject<{
-        source: z.ZodLiteral<"stattic-variables">;
-        names: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>;
     artifact: z.ZodObject<{
         format: z.ZodLiteral<"stattic.zero.capsule.v1">;
         appName: z.ZodString;
@@ -1318,6 +1385,9 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
@@ -1332,6 +1402,9 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
                 env: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 realtime: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
                 logging: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                gravatar: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                spam: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                email: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
             }, z.core.$strip>>;
             db: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
@@ -1429,22 +1502,23 @@ export declare const zeroDeployMetadataSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type ZeroDeployMetadata = z.infer<typeof zeroDeployMetadataSchema>;
 /**
- * What a live Zero capsule is, as the `app` member of a space's runtime status.
+ * What a live Zero capsule is, as the `capsule` member of a space's runtime
+ * status.
  *
  * There is no `versionId` here: this only ever describes the version the status
  * response already names as live, and repeating it would invite the two to
  * disagree. `artifactId` stays because it identifies the built capsule rather
- * than the publish that carries it.
+ * than the publish that carries it. There is no kind tag either — the member it
+ * rides in already says which product answered.
  *
  * Every field is derived from the version's own finalize metadata, which is
  * what makes this safe to answer for a space whose runtime is asleep,
  * mid-move, or failing: nothing here costs a call to the space's origin. It is
  * also why there are no counts of things listed here — a caller that wants
  * `tables.length` can take it — and why the database is not a field: a capsule
- * always owns one, so `runtimeKind: "zero"` already said so.
+ * always owns one, so its presence already said so.
  */
 export declare const zeroAppSchema: z.ZodObject<{
-    runtimeKind: z.ZodLiteral<"zero">;
     artifactId: z.ZodString;
     appName: z.ZodString;
     serverRuntime: z.ZodLiteral<"quickjs-rust">;
@@ -1525,49 +1599,6 @@ export declare const zeroAppSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type ZeroApp = z.infer<typeof zeroAppSchema>;
-export declare const zeroLogListQuerySchema: z.ZodObject<{
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    cursor: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    handlerName: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type ZeroLogListQuery = z.infer<typeof zeroLogListQuerySchema>;
-export declare const zeroLogEntrySchema: z.ZodObject<{
-    id: z.ZodString;
-    timestamp: z.ZodString;
-    level: z.ZodEnum<{
-        info: "info";
-        error: "error";
-        debug: "debug";
-        warn: "warn";
-    }>;
-    requestId: z.ZodNullable<z.ZodString>;
-    versionId: z.ZodNullable<z.ZodString>;
-    handlerName: z.ZodNullable<z.ZodString>;
-    message: z.ZodString;
-    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export declare const zeroLogListResponseSchema: z.ZodObject<{
-    data: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        timestamp: z.ZodString;
-        level: z.ZodEnum<{
-            info: "info";
-            error: "error";
-            debug: "debug";
-            warn: "warn";
-        }>;
-        requestId: z.ZodNullable<z.ZodString>;
-        versionId: z.ZodNullable<z.ZodString>;
-        handlerName: z.ZodNullable<z.ZodString>;
-        message: z.ZodString;
-        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strict>>;
-    pagination: z.ZodObject<{
-        nextCursor: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type ZeroLogListResponse = z.infer<typeof zeroLogListResponseSchema>;
 export declare const zeroRealtimeEventIntakeResponseSchema: z.ZodObject<{
     accepted: z.ZodLiteral<true>;
     eventId: z.ZodString;