@sudobility/screenwriter_types 0.1.1

package/dist/packets/index.js

@@ -0,0 +1,312 @@
+/**
+ * Production packets (spec 11 §7, spec 05 §6.22), slice B10. Schemas are the contract MCP and generators consume
+ * (`scenePacketSchema` and friends); the API validates its own output against them in tests.
+ * Asset lists are always empty until slice B11 (assets) lands.
+ */
+import { z } from 'zod';
+export const PACKET_VERSION = 1;
+/**
+ * `?snapshotId=&include=` shared by the four packet routes. `include` is a comma list added to the defaults (`assets` and
+ * `script` are on by default; `neighbors` and `pages` are opt-in; `-script` and `-assets` switch a default off).
+ */
+export const PACKET_INCLUDE_FLAGS = [
+    'assets',
+    'assetUrls',
+    'script',
+    'neighbors',
+    'pages',
+];
+export const packetQuerySchema = z.object({
+    snapshotId: z.string().min(1).optional(),
+    include: z
+        .preprocess((v) => typeof v === 'string'
+        ? v
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : v, z.array(z.enum([
+        'assets',
+        'assetUrls=original',
+        'script',
+        'neighbors',
+        'pages',
+        '-assets',
+        '-script',
+    ])))
+        .optional(),
+});
+/** 2 MB JSON cap (spec 11 §7.1): beyond it script text is truncated per element with `truncated: true`. */
+export const PACKET_MAX_BYTES = 2 * 1024 * 1024;
+const envelope = (kind, body) => z.object({
+    packetVersion: z.literal(PACKET_VERSION),
+    kind: z.literal(kind),
+    documentId: z.string(),
+    documentTitle: z.string(),
+    snapshotId: z.string().nullable(),
+    templateId: z.string(),
+    language: z.string(),
+    generatedAt: z.string(),
+    /** `packetHash` of the packet without `generatedAt`, `hash` and signed-URL fields (spec 11 §4.2). */
+    hash: z.string(),
+    truncated: z.boolean().optional(),
+    body,
+});
+const assetSummary = z
+    .object({
+    assetId: z.string(),
+    role: z.string(),
+    kind: z.string(),
+    title: z.string(),
+})
+    .passthrough();
+const pages = z
+    .object({ start: z.string(), end: z.string(), eighths: z.number().int() })
+    .nullable();
+export const packetElementSchema = z.union([
+    z.object({
+        id: z.string(),
+        type: z.literal('character'),
+        text: z.string(),
+        speakerEntityId: z.string().nullable(),
+        extension: z.string().nullable(),
+    }),
+    z.object({
+        id: z.string(),
+        type: z.literal('parenthetical'),
+        text: z.string(),
+        speakerEntityId: z.string().nullable(),
+    }),
+    z.object({
+        id: z.string(),
+        type: z.literal('dialogue'),
+        text: z.string(),
+        speakerEntityId: z.string().nullable(),
+        dual: z.boolean(),
+        lineIndex: z.number().int(),
+    }),
+    // every other role: sceneHeading, action, transition, shot, normal, ...
+    z.object({
+        id: z.string(),
+        type: z
+            .string()
+            .refine((t) => !['character', 'parenthetical', 'dialogue'].includes(t)),
+        text: z.string(),
+    }),
+]);
+const shotSummary = z.object({
+    id: z.string(),
+    number: z.string().nullable(),
+    label: z.string().nullable(),
+    status: z.string(),
+    camera: z.record(z.string(), z.unknown()),
+    estimatedDurationMs: z.number().nullable(),
+    description: z.string().nullable(),
+    elementIds: z.array(z.string()),
+    contentHash: z.string(),
+    assets: z.array(assetSummary),
+});
+const sceneRef = z.object({
+    id: z.string(),
+    number: z.string().nullable(),
+    heading: z.string(),
+    synopsis: z.string(),
+});
+const sceneHeader = z.object({
+    id: z.string(),
+    number: z.string().nullable(),
+    ordinal: z.number().int(),
+    omitted: z.boolean(),
+    heading: z.object({
+        raw: z.string(),
+        intro: z.string().nullable(),
+        location: z.string().nullable(),
+        time: z.string().nullable(),
+    }),
+    locationEntityId: z.string().nullable(),
+    synopsis: z.string(),
+    color: z.string().nullable(),
+    pages,
+    estimatedDurationMs: z.number(),
+    folders: z.array(z.object({ id: z.string(), kind: z.string(), title: z.string() })),
+    contentHash: z.string(),
+    scriptDay: z.string().nullable(),
+});
+const locationBlock = z
+    .object({
+    entityId: z.string(),
+    name: z.string(),
+    fields: z.record(z.string(), z.unknown()),
+    description: z.string(),
+    assets: z.array(assetSummary),
+})
+    .nullable();
+export const scenePacketBodySchema = z.object({
+    scene: sceneHeader,
+    script: z.array(packetElementSchema),
+    cast: z.array(z.object({
+        entityId: z.string(),
+        name: z.string(),
+        speaking: z.boolean(),
+        lineCount: z.number().int(),
+        wordCount: z.number().int(),
+        firstAppearance: z.boolean(),
+        summary: z.string(),
+        fields: z.record(z.string(), z.unknown()),
+        traits: z.record(z.string(), z.union([z.string(), z.number()])),
+        assets: z.array(assetSummary),
+    })),
+    location: locationBlock,
+    elements: z.array(z.object({
+        entityId: z.string(),
+        kind: z.string(),
+        name: z.string(),
+        description: z.string(),
+        tagCount: z.number().int(),
+        assets: z.array(assetSummary),
+    })),
+    shots: z.array(shotSummary),
+    notes: z.array(z.object({
+        id: z.string(),
+        type: z.string(),
+        text: z.string(),
+        anchorElementId: z.string().nullable(),
+    })),
+    sceneAssets: z.array(assetSummary),
+    neighbors: z
+        .object({ previous: sceneRef.nullable(), next: sceneRef.nullable() })
+        .optional(),
+});
+export const scenePacketSchema = envelope('scene', scenePacketBodySchema);
+export const characterPacketBodySchema = z.object({
+    character: z.object({
+        id: z.string(),
+        name: z.string(),
+        aliases: z.array(z.string()),
+        description: z.string(),
+        fields: z.record(z.string(), z.unknown()),
+        traits: z.record(z.string(), z.union([z.string(), z.number()])),
+        attributes: z.record(z.string(), z.unknown()),
+        contentHash: z.string(),
+    }),
+    ages: z.array(z.object({
+        id: z.string(),
+        label: z.string(),
+        ageValue: z.number().nullable(),
+        description: z.string(),
+        skeleton: z.array(z.object({
+            section: z.string().nullable(),
+            label: z.string(),
+            answer: z.string(),
+        })),
+        appearances: z.array(z.object({
+            id: z.string(),
+            label: z.string(),
+            description: z.string(),
+            assetIds: z.array(z.string()),
+        })),
+        sceneCount: z.number().int(),
+    })),
+    skeleton: z.array(z.object({
+        section: z.string().nullable(),
+        label: z.string(),
+        answer: z.string(),
+    })),
+    stats: z.object({
+        sceneCount: z.number().int(),
+        speakingSceneCount: z.number().int(),
+        lineCount: z.number().int(),
+        wordCount: z.number().int(),
+        firstSceneId: z.string().nullable(),
+        lastSceneId: z.string().nullable(),
+    }),
+    scenes: z.array(z.object({
+        id: z.string(),
+        number: z.string().nullable(),
+        heading: z.string(),
+        speaking: z.boolean(),
+        lineCount: z.number().int(),
+        ageId: z.string().nullable(),
+        appearanceId: z.string().nullable(),
+    })),
+    sampleDialogue: z.array(z.object({ elementId: z.string(), sceneId: z.string(), text: z.string() })),
+    relationships: z.array(z.object({
+        entityId: z.string(),
+        name: z.string(),
+        sharedSceneCount: z.number().int(),
+    })),
+    props: z.array(z.object({ entityId: z.string(), name: z.string() })),
+    assets: z.array(assetSummary),
+});
+export const characterPacketSchema = envelope('character', characterPacketBodySchema);
+export const locationPacketBodySchema = z.object({
+    location: z.object({
+        id: z.string(),
+        name: z.string(),
+        aliases: z.array(z.string()),
+        description: z.string(),
+        fields: z.record(z.string(), z.unknown()),
+        parent: z.object({ id: z.string(), name: z.string() }).nullable(),
+        children: z.array(z.object({ id: z.string(), name: z.string() })),
+        contentHash: z.string(),
+    }),
+    versions: z.array(z.object({
+        id: z.string(),
+        label: z.string(),
+        description: z.string(),
+        setting: z.string().nullable(),
+        sceneCount: z.number().int(),
+    })),
+    scenes: z.array(z.object({
+        id: z.string(),
+        number: z.string().nullable(),
+        heading: z.string(),
+        time: z.string().nullable(),
+        pages,
+        cast: z.array(z.string()),
+        versionId: z.string().nullable(),
+    })),
+    totals: z.object({
+        sceneCount: z.number().int(),
+        eighths: z.number().int(),
+        timesOfDay: z.record(z.string(), z.number().int()),
+    }),
+    setElements: z.array(z.object({ entityId: z.string(), kind: z.string(), name: z.string() })),
+    assets: z.array(assetSummary),
+});
+export const locationPacketSchema = envelope('location', locationPacketBodySchema);
+export const shotPacketBodySchema = z.object({
+    shot: shotSummary.extend({
+        sceneId: z.string(),
+        range: z
+            .object({
+            startElementId: z.string(),
+            endElementId: z.string(),
+            text: z.string(),
+        })
+            .nullable(),
+    }),
+    scene: z.object({
+        id: z.string(),
+        number: z.string().nullable(),
+        heading: z.object({
+            raw: z.string(),
+            intro: z.string().nullable(),
+            location: z.string().nullable(),
+            time: z.string().nullable(),
+        }),
+        locationEntityId: z.string().nullable(),
+        contentHash: z.string(),
+    }),
+    script: z.array(packetElementSchema),
+    subjects: z.array(z.object({
+        entityId: z.string(),
+        kind: z.string(),
+        name: z.string(),
+        fields: z.record(z.string(), z.unknown()),
+        assets: z.array(assetSummary),
+    })),
+    location: locationBlock,
+    previousShot: shotSummary.nullable(),
+    nextShot: shotSummary.nullable(),
+});
+export const shotPacketSchema = envelope('shot', shotPacketBodySchema);

package/dist/projects/index.d.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { DOCUMENT_KINDS } from '@sudobility/writing_core';
+import type { DocumentKind } from '@sudobility/writing_core';
+import type { Role } from '../tenancy/index.js';
+export { DOCUMENT_KINDS };
+export type { DocumentKind };
+export declare const documentKindSchema: z.ZodEnum<{
+    outline: "outline";
+    script: "script";
+    bible: "bible";
+    treatment: "treatment";
+    other: "other";
+}>;
+export declare const SORT_OPTIONS: readonly ["updated", "name", "created"];
+/** Spec 05 §6.26: a `series` project orders its episodes by `(season, episode)` (F-COL-006). */
+export declare const PROJECT_KINDS: readonly ["feature", "series", "play", "other"];
+export type ProjectKind = (typeof PROJECT_KINDS)[number];
+export declare const projectKindSchema: z.ZodEnum<{
+    other: "other";
+    feature: "feature";
+    series: "series";
+    play: "play";
+}>;
+/** Document labels (F-COL-006): at most 20 per document, each 1-40 characters. */
+export declare const DOCUMENT_LABELS_MAX = 20;
+export declare const DOCUMENT_LABEL_MAX_CHARS = 40;
+export declare const documentLabelsSchema: z.ZodArray<z.ZodString>;
+export interface ProjectSummary {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    coverAssetId: string | null;
+    kind: ProjectKind;
+    logline: string | null;
+    documentCount: number;
+    createdAt: string;
+    updatedAt: string;
+    trashedAt: string | null;
+}
+export interface DocumentMeta {
+    id: string;
+    projectId: string;
+    workspaceId: string;
+    folderId: string | null;
+    kind: DocumentKind;
+    title: string;
+    logline: string | null;
+    color: string | null;
+    labels: string[];
+    /** Series projects: episodes order by `(season, episode)`. */
+    season: number | null;
+    episode: number | null;
+    position: number;
+    language: string;
+    templateId: string | null;
+    templateVersion: number | null;
+    epoch: number;
+    excludeFromAi: boolean;
+    locked: boolean;
+    pageCount: number;
+    sceneCount: number;
+    wordCount: number;
+    parentSnapshotId: string | null;
+    createdBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+    lastEditedAt: string | null;
+    trashedAt: string | null;
+}
+export interface ProjectFolder {
+    id: string;
+    projectId: string;
+    parentFolderId: string | null;
+    name: string;
+    position: number;
+}
+/** `GET /projects/:pid` */
+export interface Project extends ProjectSummary {
+    role: Role;
+    folders: ProjectFolder[];
+    documents: DocumentMeta[];
+}
+export declare const projectCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    coverAssetId: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        feature: "feature";
+        series: "series";
+        play: "play";
+    }>>;
+    logline: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectCreateRequest = z.infer<typeof projectCreateSchema>;
+export declare const projectUpdateSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    coverAssetId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        feature: "feature";
+        series: "series";
+        play: "play";
+    }>>;
+    logline: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectUpdateRequest = z.infer<typeof projectUpdateSchema>;
+export declare const projectListQuerySchema: z.ZodObject<{
+    trashed: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>>;
+    q: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        updated: "updated";
+        created: "created";
+    }>>;
+}, z.core.$strip>;
+export type ProjectListQuery = z.infer<typeof projectListQuerySchema>;
+export declare const documentCreateSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        outline: "outline";
+        script: "script";
+        bible: "bible";
+        treatment: "treatment";
+        other: "other";
+    }>;
+    folderId: z.ZodOptional<z.ZodString>;
+    templateId: z.ZodOptional<z.ZodString>;
+    templateVersion: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    season: z.ZodOptional<z.ZodNumber>;
+    episode: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DocumentCreateRequest = z.infer<typeof documentCreateSchema>;
+export declare const documentUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    folderId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    position: z.ZodOptional<z.ZodNumber>;
+    color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    language: z.ZodOptional<z.ZodString>;
+    logline: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    excludeFromAi: z.ZodOptional<z.ZodBoolean>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    season: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    episode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type DocumentUpdateRequest = z.infer<typeof documentUpdateSchema>;
+export declare const documentListQuerySchema: z.ZodObject<{
+    trashed: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>>;
+    folderId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        outline: "outline";
+        script: "script";
+        bible: "bible";
+        treatment: "treatment";
+        other: "other";
+    }>>;
+    order: z.ZodOptional<z.ZodEnum<{
+        episode: "episode";
+        position: "position";
+    }>>;
+}, z.core.$strip>;
+export type DocumentListQuery = z.infer<typeof documentListQuerySchema>;
+/** Style row in `DocumentDetail.template` (`code` = shortcut digit, `enter`/`tab` = next style ids). */
+export interface DocumentTemplateStyle {
+    id: string;
+    name: string;
+    code: number | null;
+    enter: string | null;
+    tab: string | null;
+}
+export interface DocumentTemplateInfo {
+    id: string;
+    version: number;
+    name: string;
+    layoutMode: 'flow' | 'panels';
+    styles: DocumentTemplateStyle[];
+}
+/** `GET /documents/:did` (metadata plus live-state facts, no content). */
+export interface DocumentDetail extends DocumentMeta {
+    role: Role;
+    schemaVersion: number;
+    template: DocumentTemplateInfo | null;
+}
+export interface TrashResult {
+    trashedAt: string;
+}

package/dist/projects/index.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { DOCUMENT_KINDS } from '@sudobility/writing_core';
+export { DOCUMENT_KINDS };
+export const documentKindSchema = z.enum(DOCUMENT_KINDS);
+export const SORT_OPTIONS = ['updated', 'name', 'created'];
+/** Spec 05 §6.26: a `series` project orders its episodes by `(season, episode)` (F-COL-006). */
+export const PROJECT_KINDS = ['feature', 'series', 'play', 'other'];
+export const projectKindSchema = z.enum(PROJECT_KINDS);
+/** Document labels (F-COL-006): at most 20 per document, each 1-40 characters. */
+export const DOCUMENT_LABELS_MAX = 20;
+export const DOCUMENT_LABEL_MAX_CHARS = 40;
+export const documentLabelsSchema = z
+    .array(z.string().trim().min(1).max(DOCUMENT_LABEL_MAX_CHARS))
+    .max(DOCUMENT_LABELS_MAX);
+export const projectCreateSchema = z.object({
+    name: z.string().trim().min(1).max(200),
+    description: z.string().max(2000).optional(),
+    coverAssetId: z.string().optional(),
+    color: z.string().max(32).optional(),
+    kind: projectKindSchema.optional(),
+    logline: z.string().max(2000).optional(),
+});
+export const projectUpdateSchema = z.object({
+    name: z.string().trim().min(1).max(200).optional(),
+    description: z.string().max(2000).nullable().optional(),
+    coverAssetId: z.string().nullable().optional(),
+    color: z.string().max(32).nullable().optional(),
+    kind: projectKindSchema.optional(),
+    logline: z.string().max(2000).nullable().optional(),
+    workspaceId: z.string().optional(),
+});
+export const projectListQuerySchema = z.object({
+    trashed: z
+        .enum(['true', 'false'])
+        .transform((v) => v === 'true')
+        .optional(),
+    q: z.string().optional(),
+    sort: z.enum(SORT_OPTIONS).optional(),
+});
+// ─── Documents (spec 05 §6.7) ───────────────────────────────────────────────
+export const documentCreateSchema = z.object({
+    /** Client-generated `doc_...`; creation is idempotent on it. */
+    id: z.string().startsWith('doc_').optional(),
+    title: z.string().trim().min(1).max(200),
+    kind: documentKindSchema,
+    folderId: z.string().optional(),
+    templateId: z.string().optional(),
+    templateVersion: z.number().int().positive().optional(),
+    language: z.string().max(16).optional(),
+    labels: documentLabelsSchema.optional(),
+    season: z.number().int().min(0).max(9999).optional(),
+    episode: z.number().int().min(0).max(99999).optional(),
+});
+export const documentUpdateSchema = z.object({
+    title: z.string().trim().min(1).max(200).optional(),
+    folderId: z.string().nullable().optional(),
+    position: z.number().optional(),
+    color: z.string().max(32).nullable().optional(),
+    language: z.string().max(16).optional(),
+    logline: z.string().max(2000).nullable().optional(),
+    excludeFromAi: z.boolean().optional(),
+    labels: documentLabelsSchema.optional(),
+    season: z.number().int().min(0).max(9999).nullable().optional(),
+    episode: z.number().int().min(0).max(99999).nullable().optional(),
+});
+export const documentListQuerySchema = z.object({
+    trashed: z
+        .enum(['true', 'false'])
+        .transform((v) => v === 'true')
+        .optional(),
+    folderId: z.string().optional(),
+    kind: documentKindSchema.optional(),
+    /** `episode` = `(season, episode)` with unnumbered documents last; the default for a `series` project. */
+    order: z.enum(['position', 'episode']).optional(),
+});

package/dist/public/index.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+/**
+ * Public routes (spec 05 §6.21, B18): no session needed. `/public/templates[/:key]` reuse `TemplateSummary`
+ * (templates/index.ts) and writing_core's `TemplateJSON` for the full body.
+ */
+/** `GET /public/config` (R31): the single client-policy route. Clients below `minClientVersion` show the update
+ *  prompt; a call from one is answered `CLIENT_TOO_OLD` (426), read from the `X-Client-Version` request header. */
+export interface PublicConfig {
+    uiLanguages: string[];
+    scriptLanguages: string[];
+    assetLimits: Record<string, unknown>;
+    maxImportBytes: number;
+    importFormats: string[];
+    exportFormats: string[];
+    aiTasks: {
+        task: string;
+        pricingBasis: string;
+    }[];
+    aiConsentVersion: number;
+    syncProtocolVersion: number;
+    docSchemaVersion: number;
+    minClientVersion: {
+        web: string;
+        ios: string;
+        android: string;
+        macos: string;
+        windows: string;
+    };
+    namesDbVersion: number;
+    features: {
+        ocr: boolean;
+        grammar: boolean;
+        push: boolean;
+    };
+}
+/** `GET /public/names-db/:version` (spec 09): served gzipped with a far-future immutable Cache-Control. */
+export interface NamesDbEntry {
+    name: string;
+    gender?: 'f' | 'm' | 'u';
+    origins: string[];
+}
+export interface NamesDbResponse {
+    version: number;
+    names: NamesDbEntry[];
+}
+/** `GET /public/health/deep`: readiness, no secrets. */
+export interface DeepHealthResponse {
+    db: 'ok' | 'error';
+    storage: 'ok' | 'unconfigured' | 'error';
+    ai: 'ok' | 'unconfigured';
+    email: 'ok' | 'unconfigured';
+}
+/** `GET /public/watermarked/:exportId/:token`: the recipient's download page payload (never the file itself). */
+export interface WatermarkedDownloadInfo {
+    documentTitle: string;
+    senderName: string;
+    url: string;
+    expiresAt: string;
+}
+/** `POST /public/purchases/handoff/redeem`: exchanges a handoff token for a Firebase custom token (same uid), so the web page signs in without a password. */
+export declare const purchaseHandoffRedeemSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+export type PurchaseHandoffRedeemRequest = z.infer<typeof purchaseHandoffRedeemSchema>;
+export interface PurchaseHandoffRedeemResponse {
+    customToken: string;
+}
+export declare const telemetryEventSchema: z.ZodObject<{
+    name: z.ZodString;
+    ts: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strip>;
+export type TelemetryEvent = z.infer<typeof telemetryEventSchema>;
+export declare const clientErrorReportSchema: z.ZodObject<{
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strip>;
+export type ClientErrorReport = z.infer<typeof clientErrorReportSchema>;
+export declare const telemetryRequestSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ts: z.ZodString;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strip>>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type TelemetryRequest = z.infer<typeof telemetryRequestSchema>;
+export interface TelemetryResponse {
+    accepted: boolean;
+}