@spacefast/common 0.0.2

package/dist/contracts/activity.js

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { AnyObjectSchema, CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
+// The single event taxonomy (internal-docs/platform.md "Event taxonomy").
+// Every emitted activity event and every webhook `events` filter selects on
+// these codes. Growth is additive-only: codes are never renamed or removed.
+// `appendActivityEvent` is typed against this list, so emitting a code that is
+// not in the table is a typecheck (CI) failure.
+export const ACTIVITY_EVENT_CODES = [
+    // space
+    "space.created",
+    "space.claimed",
+    "space.transferred",
+    "space.moved",
+    "space.expired",
+    "space.disabled",
+    "space.enabled",
+    "space.deleted",
+    "space.config_updated",
+    "space.password_updated",
+    // version
+    "version.created",
+    "version.ready",
+    "version.warning",
+    "version.failed",
+    "version.expired",
+    "version.canceled",
+    "version.deleted",
+    "version.retention_warning",
+    "version.retention_deleted",
+    // channel
+    "channel.promoted",
+    // build
+    "build.created",
+    "build.succeeded",
+    "build.failed",
+    "build.canceled",
+    "build.skipped",
+    // domain
+    "domain.created",
+    "domain.verified",
+    "domain.verification_failed",
+    "domain.control_lost",
+    "domain.dns_updated",
+    "domain.nameservers_updated",
+    "domain.registration_purchased",
+    "domain.registration_renewed",
+    "domain.registration_expiring",
+    "domain.registration_expired",
+    "domain.transfer_in_started",
+    "domain.transfer_out_started",
+    "domain.deleted",
+    // binding
+    "binding.created",
+    "binding.activated",
+    "binding.blocked",
+    "binding.deleted",
+    // transfer
+    "transfer.requested",
+    "transfer.confirmed",
+    "transfer.completed",
+    "transfer.canceled",
+    "transfer.expired",
+    "transfer.failed",
+    // variable (key-level only; never values)
+    "variable.updated",
+    "variable.deleted",
+    // api_key
+    "api_key.created",
+    "api_key.updated",
+    "api_key.revoked",
+    // webhook (DELETE is a soft-disable that emits webhook.disabled; there is no
+    // webhook.deleted event — internal-docs/platform.md "Webhook DELETE")
+    "webhook.created",
+    "webhook.updated",
+    "webhook.secret_rotated",
+    "webhook.disabled",
+    // team (builds_deploys_quota_exceeded is a shipped additive extension: the
+    // pooled monthly builds+deploys meter is SOFT — it tracks, never blocks)
+    "team.updated",
+    "team.member_added",
+    "team.member_removed",
+    "team.member_role_updated",
+    "team.builds_deploys_quota_exceeded",
+    // tenant (tenant.deleted is a shipped additive extension)
+    "tenant.past_due",
+    "tenant.suspended",
+    "tenant.reactivated",
+    "tenant.deleted",
+    // export / import
+    "export.ready",
+    "export.failed",
+    "import.ready",
+    "import.failed",
+    // annotations
+    "annotation.token_minted",
+    "annotation.created",
+    "annotation.comment_created",
+    "annotation.resolved",
+    "annotation.reopened",
+    "annotation.archived",
+    // abuse (additive extension: operator-tunable abuse-control telemetry)
+    "abuse_report.created",
+    "abuse_report.updated",
+    // claim (additive extension: a claim attempt against a taken-down space is
+    // flagged, never silently 404ed — internal-docs/platform.md "Abuse Posture")
+    "claim.blocked_takedown",
+    // user (additive extension: account lifecycle plus the 2FA and
+    // admin-impersonation effects that must surface through ActivityEvent —
+    // internal-docs/platform.md Better Auth usage). `user.created` fires once on
+    // signup; `user.signed_in` fires per non-impersonation session creation;
+    // `user.deleted` fires on account deletion and retains the analyticsId in
+    // its details so right-to-erasure can be completed in every provider.
+    "user.created",
+    "user.signed_in",
+    "user.deleted",
+    "user.impersonation_started",
+    "user.impersonation_stopped",
+    "user.two_factor_enabled",
+    "user.two_factor_disabled",
+];
+const ACTIVITY_EVENT_CODE_SET = new Set(ACTIVITY_EVENT_CODES);
+const ACTIVITY_EVENT_RESOURCES = new Set(ACTIVITY_EVENT_CODES.map((code) => code.split(".", 1)[0]));
+export function isActivityEventCode(value) {
+    return ACTIVITY_EVENT_CODE_SET.has(value);
+}
+// Webhook `events` filters accept exact codes, prefix wildcards ("version.*"),
+// and the catch-all ["*"].
+export function isValidActivityEventFilter(filter) {
+    if (filter === "*") {
+        return true;
+    }
+    if (filter.endsWith(".*")) {
+        return ACTIVITY_EVENT_RESOURCES.has(filter.slice(0, -2));
+    }
+    return ACTIVITY_EVENT_CODE_SET.has(filter);
+}
+export function matchesActivityEventFilters(filters, code) {
+    return filters.some((filter) => filter === "*" ||
+        filter === code ||
+        (filter.endsWith(".*") && code.startsWith(filter.slice(0, -1))));
+}
+export const activityActorSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("user"), id: z.string().min(1) }),
+    z.object({ type: z.literal("api_key"), id: z.string().min(1) }),
+    z.object({ type: z.literal("oauth_client"), id: z.string().min(1) }),
+    z.object({ type: z.literal("anonymous_claim"), id: z.string().min(1) }),
+    z.object({ type: z.literal("system"), id: z.string().min(1) }),
+]);
+export const activityPrincipalSchema = z.object({
+    tenantId: z.string().min(1),
+    principalType: z.enum(["team", "external"]),
+    principalId: z.string().min(1),
+});
+export const activityEventSchema = z.object({
+    id: z.string(),
+    sequence: z.number().int().nonnegative(),
+    tenantId: z.string(),
+    principal: activityPrincipalSchema.nullable(),
+    spaceId: z.string().nullable(),
+    actor: activityActorSchema,
+    code: z.string(),
+    message: z.string(),
+    details: AnyObjectSchema.nullable(),
+    createdAt: z.string().datetime(),
+});
+export const activityQuerySchema = cursorListQuerySchema.extend({
+    principalType: z
+        .enum(["team", "external"])
+        .optional()
+        .describe("Filter to events owned by a team or an external customer principal."),
+    principalId: z.string().min(1).optional().describe("Filter to a single principal id."),
+    spaceId: z.string().min(1).optional().describe("Filter to events for one space."),
+    code: z.string().min(1).optional().describe("Filter to one event code, e.g. `space.created`."),
+    since: z.string().datetime().optional().describe("Only events at or after this time."),
+    until: z.string().datetime().optional().describe("Only events at or before this time."),
+});
+export const activityListResponseSchema = z.object({
+    data: z.array(activityEventSchema),
+    pagination: CursorPaginationSchema,
+});

package/dist/contracts/analytics.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export declare const DOMAIN_SSH_ANALYTICS_EVENTS: readonly ["domain_ssh_session_started", "domain_ssh_session_ended", "domain_ssh_lookup_requested"];
+export declare const ANALYTICS_EVENTS: readonly ["version_intent_created", "version_finalize_queued", "version_promote_queued", "publish_receipt_created", "feature_blocked", "limit_tripped", "domain_ssh_session_started", "domain_ssh_session_ended", "domain_ssh_lookup_requested"];
+export declare const analyticsEventSchema: z.ZodEnum<{
+    domain_ssh_session_started: "domain_ssh_session_started";
+    domain_ssh_session_ended: "domain_ssh_session_ended";
+    domain_ssh_lookup_requested: "domain_ssh_lookup_requested";
+    version_intent_created: "version_intent_created";
+    version_finalize_queued: "version_finalize_queued";
+    version_promote_queued: "version_promote_queued";
+    publish_receipt_created: "publish_receipt_created";
+    feature_blocked: "feature_blocked";
+    limit_tripped: "limit_tripped";
+}>;
+export type AnalyticsEvent = z.infer<typeof analyticsEventSchema>;
+export declare const DOMAIN_SSH_ANALYTICS_MAX_UNITS = 160;
+export declare const domainSshAnalyticsEventSchema: z.ZodObject<{
+    action: z.ZodOptional<z.ZodEnum<{
+        suggestions: "suggestions";
+        whois: "whois";
+        availability: "availability";
+    }>>;
+    cols: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    durationMs: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    event: z.ZodEnum<{
+        domain_ssh_session_started: "domain_ssh_session_started";
+        domain_ssh_session_ended: "domain_ssh_session_ended";
+        domain_ssh_lookup_requested: "domain_ssh_lookup_requested";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        closed: "closed";
+        ended: "ended";
+        exec_rejected: "exec_rejected";
+        lookup_rate_limited: "lookup_rate_limited";
+        renderer_failed: "renderer_failed";
+        session_limit: "session_limit";
+        shutdown: "shutdown";
+        started: "started";
+    }>>;
+    rows: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    sessionId: z.ZodString;
+    sourceFamily: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        ipv4: "ipv4";
+        ipv6: "ipv6";
+    }>>;
+    sourceHash: z.ZodOptional<z.ZodString>;
+    units: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type DomainSshAnalyticsPayload = z.infer<typeof domainSshAnalyticsEventSchema>;
+export type DomainSshAnalyticsEvent = DomainSshAnalyticsPayload["event"];
+export type DomainSshSourceFamily = DomainSshAnalyticsPayload["sourceFamily"];
+export declare const TRACKS_EVENT_PREFIX = "stattic";
+export declare function tracksEventName(name: string): string;
+export declare function tracksPropertyName(name: string): string;
+export declare function tracksProperties(properties: Record<string, unknown>): Record<string, string | number | boolean>;

package/dist/contracts/analytics.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export const DOMAIN_SSH_ANALYTICS_EVENTS = [
+    "domain_ssh_session_started",
+    "domain_ssh_session_ended",
+    "domain_ssh_lookup_requested",
+];
+// Direct product analytics events. These cover request/funnel moments that the
+// activity taxonomy (contracts/activity.ts) intentionally does NOT record —
+// queue requests, anonymous publish receipts, gating decisions. Everything
+// that IS an activity event reaches the analytics providers through the
+// activity fan-out instead, so a business moment is never captured twice.
+export const ANALYTICS_EVENTS = [
+    "version_intent_created",
+    "version_finalize_queued",
+    "version_promote_queued",
+    "publish_receipt_created",
+    "feature_blocked",
+    "limit_tripped",
+    ...DOMAIN_SSH_ANALYTICS_EVENTS,
+];
+export const analyticsEventSchema = z.enum(ANALYTICS_EVENTS);
+export const DOMAIN_SSH_ANALYTICS_MAX_UNITS = 160;
+export const domainSshAnalyticsEventSchema = z.object({
+    action: z.enum(["suggestions", "availability", "whois"]).optional(),
+    cols: z.coerce.number().int().min(1).max(500).optional(),
+    durationMs: z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(24 * 60 * 60 * 1000)
+        .optional(),
+    event: z.enum(DOMAIN_SSH_ANALYTICS_EVENTS),
+    reason: z
+        .enum([
+        "closed",
+        "ended",
+        "exec_rejected",
+        "lookup_rate_limited",
+        "renderer_failed",
+        "session_limit",
+        "shutdown",
+        "started",
+    ])
+        .optional(),
+    rows: z.coerce.number().int().min(1).max(200).optional(),
+    sessionId: z
+        .string()
+        .trim()
+        .min(8)
+        .max(96)
+        .regex(/^[A-Za-z0-9:_-]+$/),
+    sourceFamily: z.enum(["ipv4", "ipv6", "unknown"]).default("unknown"),
+    sourceHash: z
+        .string()
+        .trim()
+        .regex(/^[a-f0-9]{64}$/)
+        .optional(),
+    units: z.coerce.number().int().min(1).max(DOMAIN_SSH_ANALYTICS_MAX_UNITS).optional(),
+});
+// Tracks (Automattic analytics) naming rules, shared by the browser pixel
+// client and the control-plane REST client: event names are
+// `stattic_<noun>_<verb>` snake_case tokens and property names are lowercase
+// snake_case (calypso-analytics validation rules). Internal names use dots
+// (`space.created`, `cli.command`) and camelCase details, so both normalize.
+export const TRACKS_EVENT_PREFIX = "stattic";
+export function tracksEventName(name) {
+    const normalized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return `${TRACKS_EVENT_PREFIX}_${normalized}`;
+}
+export function tracksPropertyName(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, "_")
+        .replace(/^([0-9])/, "_$1");
+}
+export function tracksProperties(properties) {
+    const result = {};
+    for (const [key, value] of Object.entries(properties)) {
+        if (value === null || value === undefined) {
+            continue;
+        }
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            result[tracksPropertyName(key)] = value;
+        }
+    }
+    return result;
+}

package/dist/contracts/annotations.d.ts

@@ -0,0 +1,327 @@
+import { z } from "zod";
+export declare const collaborationModeSchema: z.ZodEnum<{
+    review: "review";
+}>;
+export declare const annotationThreadStatusSchema: z.ZodEnum<{
+    open: "open";
+    resolved: "resolved";
+    archived: "archived";
+}>;
+export declare const collaborationReviewerLevelSchema: z.ZodEnum<{
+    viewer: "viewer";
+    commenter: "commenter";
+    editor: "editor";
+}>;
+export declare const collaborationInvitedReviewerSchema: z.ZodObject<{
+    email: z.ZodString;
+    level: z.ZodEnum<{
+        viewer: "viewer";
+        commenter: "commenter";
+        editor: "editor";
+    }>;
+}, z.core.$strip>;
+export declare const collaborationSettingsSchema: z.ZodObject<{
+    anonymousReviewers: z.ZodOptional<z.ZodBoolean>;
+    invitedReviewers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        email: z.ZodString;
+        level: z.ZodEnum<{
+            viewer: "viewer";
+            commenter: "commenter";
+            editor: "editor";
+        }>;
+    }, z.core.$strip>>>;
+    publishedComments: z.ZodOptional<z.ZodBoolean>;
+    allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    notificationPreferences: z.ZodOptional<z.ZodObject<{
+        newThreads: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        newReplies: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        statusChanges: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, z.core.$strip>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export declare const collaborationSchema: z.ZodObject<{
+    spaceId: z.ZodString;
+    enabled: z.ZodBoolean;
+    mode: z.ZodEnum<{
+        review: "review";
+    }>;
+    castResourceId: z.ZodNullable<z.ZodString>;
+    castResourceKey: z.ZodNullable<z.ZodString>;
+    settings: z.ZodObject<{
+        anonymousReviewers: z.ZodOptional<z.ZodBoolean>;
+        invitedReviewers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            email: z.ZodString;
+            level: z.ZodEnum<{
+                viewer: "viewer";
+                commenter: "commenter";
+                editor: "editor";
+            }>;
+        }, z.core.$strip>>>;
+        publishedComments: z.ZodOptional<z.ZodBoolean>;
+        allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        notificationPreferences: z.ZodOptional<z.ZodObject<{
+            newThreads: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            newReplies: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            statusChanges: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+    createdAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const collaborationUpdateSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    mode: z.ZodOptional<z.ZodEnum<{
+        review: "review";
+    }>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        anonymousReviewers: z.ZodOptional<z.ZodBoolean>;
+        invitedReviewers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            email: z.ZodString;
+            level: z.ZodEnum<{
+                viewer: "viewer";
+                commenter: "commenter";
+                editor: "editor";
+            }>;
+        }, z.core.$strip>>>;
+        publishedComments: z.ZodOptional<z.ZodBoolean>;
+        allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        notificationPreferences: z.ZodOptional<z.ZodObject<{
+            newThreads: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            newReplies: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            statusChanges: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, z.core.$strip>>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const collaborationTokenRequestSchema: z.ZodObject<{
+    versionId: z.ZodOptional<z.ZodString>;
+    pagePath: z.ZodDefault<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const collaborationTokenResponseSchema: z.ZodObject<{
+    token: z.ZodString;
+    expiresAt: z.ZodString;
+    cast: z.ZodObject<{
+        resource: z.ZodString;
+        room: z.ZodNullable<z.ZodString>;
+        loaderUrl: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const collaborationHandoffRequestSchema: z.ZodObject<{
+    versionId: z.ZodString;
+    pagePath: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const collaborationHandoffResponseSchema: z.ZodObject<{
+    handoffToken: z.ZodString;
+    expiresAt: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const collaborationHandoffExchangeSchema: z.ZodObject<{
+    handoffToken: z.ZodString;
+}, z.core.$strip>;
+export declare const realtimeTokenRequestSchema: z.ZodObject<{
+    versionId: z.ZodOptional<z.ZodString>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        space: "space";
+        version: "version";
+    }>>;
+}, z.core.$strip>;
+export declare const realtimeTokenResponseSchema: z.ZodObject<{
+    token: z.ZodString;
+    expiresAt: z.ZodString;
+    cast: z.ZodObject<{
+        resource: z.ZodString;
+        room: z.ZodString;
+        loaderUrl: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const noticePublishSchema: z.ZodObject<{
+    versionId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodDefault<z.ZodString>;
+    title: z.ZodString;
+    message: z.ZodString;
+    level: z.ZodDefault<z.ZodEnum<{
+        success: "success";
+        info: "info";
+        warning: "warning";
+        error: "error";
+    }>>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    durable: z.ZodDefault<z.ZodBoolean>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const noticePublishResponseSchema: z.ZodObject<{
+    status: z.ZodString;
+    event: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    broadcast: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const overlayConfigQuerySchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const overlayConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    features: z.ZodObject<{
+        annotations: z.ZodBoolean;
+        anonymousReviewers: z.ZodBoolean;
+        notices: z.ZodBoolean;
+    }, z.core.$strip>;
+    cast: z.ZodNullable<z.ZodObject<{
+        loaderUrl: z.ZodString;
+        resource: z.ZodString;
+        room: z.ZodString;
+        wsUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        inboxUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        threadUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tokenEndpoint: z.ZodString;
+        handoffEndpoint: z.ZodString;
+        authBridgeUrl: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const publicOverlayConfigQuerySchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const publicOverlayConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    publishedComments: z.ZodBoolean;
+    anonymousReviewers: z.ZodBoolean;
+    room: z.ZodNullable<z.ZodString>;
+    resourceKey: z.ZodNullable<z.ZodString>;
+    version: z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        current: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    sdkUrl: z.ZodString;
+    wsUrl: z.ZodNullable<z.ZodString>;
+    inboxUrl: z.ZodNullable<z.ZodString>;
+    threadUrl: z.ZodNullable<z.ZodString>;
+    tokenUrl: z.ZodString;
+    authBridgeUrl: z.ZodString;
+    level: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotationAuthorSchema: z.ZodObject<{
+    kind: z.ZodNullable<z.ZodString>;
+    id: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotationTargetSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare const annotationThreadSchema: z.ZodObject<{
+    id: z.ZodString;
+    castThreadId: z.ZodString;
+    spaceId: z.ZodString;
+    versionId: z.ZodNullable<z.ZodString>;
+    channel: z.ZodNullable<z.ZodString>;
+    pagePath: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        open: "open";
+        resolved: "resolved";
+        archived: "archived";
+    }>;
+    body: z.ZodNullable<z.ZodString>;
+    author: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodNullable<z.ZodString>;
+        id: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    target: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    comments: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    permalink: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotationListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    versionId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        resolved: "resolved";
+        archived: "archived";
+    }>>;
+    pagePath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotationCreateSchema: z.ZodObject<{
+    pagePath: z.ZodDefault<z.ZodString>;
+    body: z.ZodString;
+    target: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotationScreenshotCreateSchema: z.ZodObject<{
+    versionId: z.ZodString;
+    pagePath: z.ZodDefault<z.ZodString>;
+    contentType: z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+        "image/webp": "image/webp";
+    }>;
+    contentBase64: z.ZodString;
+}, z.core.$strip>;
+export declare const annotationScreenshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    url: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export declare const annotationReplySchema: z.ZodObject<{
+    body: z.ZodString;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const annotationPatchSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        resolved: "resolved";
+        archived: "archived";
+    }>>;
+}, z.core.$strip>;
+export declare const annotationExportQuerySchema: z.ZodObject<{
+    format: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        resolved: "resolved";
+        archived: "archived";
+    }>>;
+}, z.core.$strip>;
+export declare const annotationListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        castThreadId: z.ZodString;
+        spaceId: z.ZodString;
+        versionId: z.ZodNullable<z.ZodString>;
+        channel: z.ZodNullable<z.ZodString>;
+        pagePath: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            open: "open";
+            resolved: "resolved";
+            archived: "archived";
+        }>;
+        body: z.ZodNullable<z.ZodString>;
+        author: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodNullable<z.ZodString>;
+            id: z.ZodNullable<z.ZodString>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        target: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        comments: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        permalink: z.ZodNullable<z.ZodString>;
+        updatedAt: z.ZodNullable<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 annotationExportResponseSchema: z.ZodObject<{
+    format: z.ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type CollaborationInvitedReviewer = z.infer<typeof collaborationInvitedReviewerSchema>;
+export type Collaboration = z.infer<typeof collaborationSchema>;
+export type OverlayConfig = z.infer<typeof overlayConfigSchema>;
+export type PublicOverlayConfig = z.infer<typeof publicOverlayConfigSchema>;
+export type AnnotationThread = z.infer<typeof annotationThreadSchema>;
+export type RealtimeToken = z.infer<typeof realtimeTokenResponseSchema>;