@sudobility/screenwriter_types 0.1.1

package/dist/public/index.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** `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 const purchaseHandoffRedeemSchema = z.object({
+    token: z.string().min(1),
+});
+// ---- Telemetry (spec 05 §6.24) ----
+export const telemetryEventSchema = z.object({
+    name: z.string().min(1).max(120),
+    ts: z.string(),
+    /** Allow-listed, flat properties only: no script text, no free-form nesting. */
+    properties: z
+        .record(z.string(), z.union([z.string().max(500), z.number(), z.boolean(), z.null()]))
+        .optional(),
+});
+export const clientErrorReportSchema = z.object({
+    message: z.string().min(1).max(2000),
+    stack: z.string().max(8000).optional(),
+    context: z
+        .record(z.string(), z.union([z.string().max(500), z.number(), z.boolean(), z.null()]))
+        .optional(),
+});
+export const telemetryRequestSchema = z.object({
+    events: z.array(telemetryEventSchema).max(100),
+    errors: z.array(clientErrorReportSchema).max(20).optional(),
+});

package/dist/reads/index.d.ts

@@ -0,0 +1,387 @@
+/**
+ * Projection-backed reads (spec 05 §6.7.1, §6.7.2, §6.12, §6.14, §6.15, §6.17), slice B10.
+ * The Y.Doc is canonical; these are the shapes the API returns for entities, tags, notes, beats, the Bin,
+ * revisions, tracked changes, alternates, title page, statistics, shots, locators and search.
+ */
+import { z } from 'zod';
+/** Query encoding of a `SourceRef` (spec 05 §6.7.1): `live`, `snapshot:<snapshotId>` or `version:<versionId>`. */
+export declare const sourceParamSchema: z.ZodString;
+/** JSON-body source on a document route: the document is implied by the route (spec 03 `SourceRef` without `documentId`). */
+export declare const docSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"live">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"snapshot">;
+    snapshotId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"version">;
+    versionId: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type DocSource = z.infer<typeof docSourceSchema>;
+export declare const sourceQuerySchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SourceQuery = z.infer<typeof sourceQuerySchema>;
+export declare function sourceParamOf(ref: DocSource | undefined): string | undefined;
+export declare const entityListQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EntityListQuery = z.infer<typeof entityListQuerySchema>;
+export interface EntitySummary {
+    id: string;
+    kind: string;
+    name: string;
+    aliases: string[];
+    color: string | null;
+    sceneCount: number;
+    firstSceneId: string | null;
+    /** Characters only. */
+    dialogueCount?: number;
+}
+/** A character's age or a location's version (spec 01 §5.8.1), read raw from the Y.Doc. */
+export interface EntityVariantSummary {
+    id: string;
+    label: string;
+    ageValue: number | null;
+    setting: string | null;
+    sortKey: string;
+    appearances: {
+        id: string;
+        label: string;
+    }[];
+}
+export interface EntityDetail extends EntitySummary {
+    description: string;
+    fields: Record<string, unknown>;
+    attributes: Record<string, unknown>;
+    categoryId: string | null;
+    origin: string;
+    retain: boolean;
+    scenes: {
+        id: string;
+        number: string | null;
+    }[];
+    tagsByScene: Record<string, string[]>;
+    /** Asset links arrive with slice B11: always empty until then. */
+    assetLinks: {
+        assetLinkId: string;
+        role: string;
+    }[];
+    contentHash: string;
+    variants: EntityVariantSummary[];
+    worksheetIds: string[];
+}
+export declare const entityUsageQuerySchema: z.ZodObject<{
+    variantId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EntityUsageQuery = z.infer<typeof entityUsageQuerySchema>;
+export interface SceneRef {
+    id: string;
+    number: string | null;
+    heading?: string;
+    synopsis?: string;
+}
+/**
+ * What blocks deleting an entity and what the character and location lists show behind *Show usages*
+ * (spec 09 F-TAG-017, F-TAG-021). `total` = cues + headings + tags + arcBeats + noteMentions + assetLinks
+ * (`sceneLinks` is the informational scene presence and is not counted).
+ */
+export interface EntityUsage {
+    total: number;
+    cues: {
+        elementId: string;
+        sceneId: string | null;
+        sceneNumber: string | null;
+        page: string | null;
+        variantId: string | null;
+    }[];
+    headings: {
+        sceneId: string;
+        sceneNumber: string | null;
+        page: string | null;
+        variantId: string | null;
+    }[];
+    sceneLinks: SceneRef[];
+    tags: {
+        tagId: string;
+        categoryId: string;
+        sceneId: string | null;
+    }[];
+    arcBeats: SceneRef[];
+    noteMentions: {
+        noteId: string;
+    }[];
+    assetLinks: {
+        assetLinkId: string;
+        role: string;
+    }[];
+    byVariant: Record<string, number>;
+    /** Uses (cues for a character, headings for a location) that name no variant. */
+    unassigned: number;
+}
+export declare const entityDialogueQuerySchema: z.ZodObject<{
+    sceneIds: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Dialogue Tuner view (spec 05 §6.7.1). */
+export interface DialogueSceneView {
+    sceneId: string;
+    sceneNumber: string | null;
+    elements: {
+        id: string;
+        styleId: string;
+        text: string;
+        contentHash: string;
+    }[];
+}
+export interface TagCategoryRow {
+    id: string;
+    key: string | null;
+    name: string;
+    color: string;
+    entityKind: string;
+}
+export declare const tagsQuerySchema: z.ZodObject<{
+    sceneId: z.ZodOptional<z.ZodString>;
+    categoryId: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface TagRow {
+    id: string;
+    categoryId: string;
+    entityId: string;
+    elementId: string;
+    range: {
+        index: number;
+        length: number;
+    } | null;
+    text: string;
+    sceneId: string | null;
+}
+export declare const notesQuerySchema: z.ZodObject<{
+    sceneId: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        resolved: "resolved";
+        open: "open";
+    }>>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface NoteSummary {
+    id: string;
+    anchor: {
+        kind: string;
+        elementId?: string;
+        beatId?: string;
+    };
+    sceneId: string | null;
+    /** The note type's name (falls back to its id). */
+    type: string | null;
+    typeId: string | null;
+    color: string | null;
+    title: string;
+    body: string;
+    author: string | null;
+    createdAt: number | null;
+    replies: {
+        id: string;
+        author: string;
+        body: string;
+        at: number;
+    }[];
+    status: 'open' | 'resolved';
+    contentHash: string;
+}
+export interface BeatRow {
+    id: string;
+    title: string;
+    body: string;
+    color: string | null;
+    x: number | null;
+    y: number | null;
+    links: {
+        id: string;
+        to: string;
+        label: string;
+    }[];
+    sceneId?: string;
+}
+export interface BinRow {
+    id: string;
+    title: string;
+    preview: string;
+    createdAt: number;
+}
+export interface RevisionsView {
+    sets: {
+        id: string;
+        name: string;
+        color: string;
+        mark: string;
+        fullDraft: boolean;
+        date: number | null;
+    }[];
+    activeSetId: string | null;
+    revisionMode: boolean;
+    trackChanges: boolean;
+}
+export declare const changesQuerySchema: z.ZodObject<{
+    authorId: z.ZodOptional<z.ZodString>;
+    sceneId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface ChangeRow {
+    id: string;
+    kind: 'insert' | 'delete' | 'style' | 'fmt';
+    authorId: string;
+    at: number;
+    elementId: string;
+    before: string;
+    after: string;
+}
+/** The element's own text is the active alternate (index 0); the inactive ones follow. */
+export interface AlternatesView {
+    activeIndex: number;
+    alternates: {
+        id: string;
+        text: string;
+    }[];
+}
+export interface TitlePageRead {
+    fields: Record<string, string>;
+    elements: {
+        id: string;
+        styleId: string;
+        text: string;
+        field: string | null;
+    }[];
+    computed: Record<string, unknown>;
+}
+export interface StatsRead {
+    pages: number;
+    eighths: number;
+    scenes: number;
+    words: number;
+    elementsByStyle: Record<string, number>;
+    estRuntimeMin: number;
+    intExt: Record<string, number>;
+    dayNight: Record<string, number>;
+    dialoguePct: number;
+}
+export interface ShotRow {
+    id: string;
+    index: number;
+    sceneId: string;
+    label: string;
+    description: string;
+    elementRange: {
+        startElementId: string;
+        endElementId: string;
+    } | null;
+    camera: Record<string, unknown>;
+    estDurationSec: number | null;
+    attributes: Record<string, unknown>;
+    contentHash: string;
+}
+export declare const fountainQuerySchema: z.ZodObject<{
+    sceneIds: z.ZodOptional<z.ZodString>;
+    fromSceneId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** `GET /documents/:did/fountain` truncates at this many bytes and sets `X-Next-From-Scene`. */
+export declare const FOUNTAIN_MAX_BYTES = 1000000;
+export declare const LOCATOR_KINDS: readonly ["scene", "element", "shot", "entity", "page"];
+export type LocatorKind = (typeof LOCATOR_KINDS)[number];
+export type ResolveResult = {
+    status: 'resolved';
+    kind: LocatorKind;
+    id: string;
+    label: string;
+} | {
+    status: 'ambiguous';
+    kind: LocatorKind;
+    candidates: {
+        id: string;
+        label: string;
+        score: number;
+    }[];
+} | {
+    status: 'not_found';
+    kind: LocatorKind;
+    suggestions: {
+        id: string;
+        label: string;
+    }[];
+};
+export declare const RESOLVE_BATCH_MAX = 200;
+export declare const resolveBatchSchema: z.ZodObject<{
+    locators: z.ZodArray<z.ZodString>;
+    snapshotId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResolveBatchRequest = z.infer<typeof resolveBatchSchema>;
+/** `GET /documents/:did/resolve?ref=&snapshotId=`. */
+export declare const resolveOneQuerySchema: z.ZodObject<{
+    ref: z.ZodString;
+    snapshotId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SEARCH_HIT_TYPES: readonly ["document", "scene", "element", "entity", "note", "asset"];
+export type SearchHitType = (typeof SEARCH_HIT_TYPES)[number];
+export declare const searchQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    q: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    documentId: z.ZodOptional<z.ZodString>;
+    types: z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodEnum<{
+        scene: "scene";
+        document: "document";
+        asset: "asset";
+        note: "note";
+        element: "element";
+        entity: "entity";
+    }>>, unknown>>;
+    styleIds: z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodString>, unknown>>;
+    characterId: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SearchQuery = z.infer<typeof searchQuerySchema>;
+/** `GET /documents/:did/search` (in-document find, spec 05 §6.7.1). */
+export declare const documentSearchQuerySchema: z.ZodObject<{
+    q: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        text: "text";
+        regex: "regex";
+    }>>;
+    styles: z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodString>, unknown>>;
+    characters: z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodString>, unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DocumentSearchQuery = z.infer<typeof documentSearchQuerySchema>;
+export interface DocumentSearchHit {
+    sceneId: string | null;
+    sceneNumber: string | null;
+    elementId: string;
+    styleId: string;
+    snippet: string;
+    page: string | null;
+}
+export interface SearchHit {
+    type: SearchHitType;
+    documentId: string | null;
+    projectId: string;
+    targetId: string;
+    title: string;
+    /** At most 240 characters; `marks` are `[start, end)` ranges into it (never HTML). */
+    snippet: string;
+    marks: [number, number][];
+    sceneNumber?: string | null;
+    pageNumber?: string | null;
+    rank: number;
+}

package/dist/reads/index.js

@@ -0,0 +1,118 @@
+/**
+ * Projection-backed reads (spec 05 §6.7.1, §6.7.2, §6.12, §6.14, §6.15, §6.17), slice B10.
+ * The Y.Doc is canonical; these are the shapes the API returns for entities, tags, notes, beats, the Bin,
+ * revisions, tracked changes, alternates, title page, statistics, shots, locators and search.
+ */
+import { z } from 'zod';
+import { cursorQuerySchema } from '../api/pagination.js';
+// ─── ?source= ───────────────────────────────────────────────────────────────
+/** Query encoding of a `SourceRef` (spec 05 §6.7.1): `live`, `snapshot:<snapshotId>` or `version:<versionId>`. */
+export const sourceParamSchema = z
+    .string()
+    .regex(/^(live|snapshot:[A-Za-z0-9_-]+|version:[A-Za-z0-9_-]+)$/, 'source must be live, snapshot:<id> or version:<id>');
+/** JSON-body source on a document route: the document is implied by the route (spec 03 `SourceRef` without `documentId`). */
+export const docSourceSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('live') }),
+    z.object({ kind: z.literal('snapshot'), snapshotId: z.string().min(1) }),
+    z.object({ kind: z.literal('version'), versionId: z.string().min(1) }),
+]);
+export const sourceQuerySchema = z.object({
+    source: sourceParamSchema.optional(),
+});
+export function sourceParamOf(ref) {
+    if (!ref || ref.kind === 'live')
+        return undefined;
+    return ref.kind === 'snapshot'
+        ? `snapshot:${ref.snapshotId}`
+        : `version:${ref.versionId}`;
+}
+// ─── Entities (spec 05 §6.12) ───────────────────────────────────────────────
+export const entityListQuerySchema = cursorQuerySchema.extend({
+    kind: z.string().min(1).optional(),
+    q: z.string().min(1).max(200).optional(),
+    source: sourceParamSchema.optional(),
+});
+export const entityUsageQuerySchema = z.object({
+    variantId: z.string().min(1).optional(),
+    source: sourceParamSchema.optional(),
+});
+export const entityDialogueQuerySchema = z.object({
+    sceneIds: z.string().optional(),
+    source: sourceParamSchema.optional(),
+});
+export const tagsQuerySchema = z.object({
+    sceneId: z.string().optional(),
+    categoryId: z.string().optional(),
+    entityId: z.string().optional(),
+    source: sourceParamSchema.optional(),
+});
+export const notesQuerySchema = z.object({
+    sceneId: z.string().optional(),
+    type: z.string().optional(),
+    status: z.enum(['open', 'resolved']).optional(),
+    source: sourceParamSchema.optional(),
+});
+export const changesQuerySchema = z.object({
+    authorId: z.string().optional(),
+    sceneId: z.string().optional(),
+    source: sourceParamSchema.optional(),
+});
+export const fountainQuerySchema = z.object({
+    sceneIds: z.string().optional(),
+    fromSceneId: z.string().optional(),
+    source: sourceParamSchema.optional(),
+});
+/** `GET /documents/:did/fountain` truncates at this many bytes and sets `X-Next-From-Scene`. */
+export const FOUNTAIN_MAX_BYTES = 1_000_000;
+// ─── Locators (spec 11 §1.3, spec 05 §6.7.2) ────────────────────────────────
+export const LOCATOR_KINDS = [
+    'scene',
+    'element',
+    'shot',
+    'entity',
+    'page',
+];
+export const RESOLVE_BATCH_MAX = 200;
+export const resolveBatchSchema = z.object({
+    locators: z.array(z.string().min(1).max(500)).min(1).max(RESOLVE_BATCH_MAX),
+    snapshotId: z.string().min(1).optional(),
+});
+/** `GET /documents/:did/resolve?ref=&snapshotId=`. */
+export const resolveOneQuerySchema = z.object({
+    ref: z.string().min(1).max(500),
+    snapshotId: z.string().min(1).optional(),
+});
+// ─── Search (spec 05 §6.17) ─────────────────────────────────────────────────
+export const SEARCH_HIT_TYPES = [
+    'document',
+    'scene',
+    'element',
+    'entity',
+    'note',
+    'asset',
+];
+const csv = (v) => typeof v === 'string'
+    ? v
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : v;
+export const searchQuerySchema = cursorQuerySchema.extend({
+    q: z.string().min(1).max(200),
+    workspaceId: z.string().min(1).optional(),
+    projectId: z.string().min(1).optional(),
+    documentId: z.string().min(1).optional(),
+    types: z.preprocess(csv, z.array(z.enum(SEARCH_HIT_TYPES)).min(1)).optional(),
+    styleIds: z.preprocess(csv, z.array(z.string()).min(1)).optional(),
+    characterId: z.string().min(1).optional(),
+    language: z.string().min(2).max(35).optional(),
+});
+/** `GET /documents/:did/search` (in-document find, spec 05 §6.7.1). */
+export const documentSearchQuerySchema = z.object({
+    q: z.string().min(1).max(500),
+    mode: z.enum(['text', 'regex']).default('text'),
+    styles: z.preprocess(csv, z.array(z.string()).min(1)).optional(),
+    characters: z.preprocess(csv, z.array(z.string()).min(1)).optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+    source: sourceParamSchema.optional(),
+});

package/dist/reports/index.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Reports (spec 09 §10 F-RPT-000..018, spec 05 §6.18), slice B10.
+ *
+ * `REPORT_KINDS` belongs in `writing_core` (spec 09 R25) but Tasks 29-35 have not landed there; until they do the
+ * vocabulary, the options and the columns live here so the API, the client and MCP share one declaration.
+ * A report is a list of tables; CSV, HTML and PDF are all rendered from those same tables, which is what
+ * F-RPT-000's acceptance ("CSV and PDF contain the same rows") rests on.
+ */
+import { z } from 'zod';
+export declare const REPORT_KINDS: readonly ["scene", "location", "character", "cast", "dialogue", "script", "text", "notes", "synopsis", "revisions", "tags", "statistics", "inclusivity", "presentProgressive", "dayOutOfDays", "shotList", "structure", "characterArcs"];
+export type ReportKind = (typeof REPORT_KINDS)[number];
+export declare const REPORT_FORMATS: readonly ["json", "csv", "pdf", "html"];
+export type ReportFormat = (typeof REPORT_FORMATS)[number];
+/** Documents up to this many pages run a report inline; larger ones answer with a `report.render` job (spec 05 §6.18). */
+export declare const REPORT_SYNC_MAX_PAGES = 200;
+export interface ReportOptionDef {
+    name: string;
+    type: 'boolean' | 'number' | 'string' | 'enum' | 'stringList';
+    default?: boolean | number | string | string[];
+    values?: readonly string[];
+    min?: number;
+    max?: number;
+    required?: boolean;
+    description?: string;
+}
+export interface ReportColumn {
+    id: string;
+    label: string;
+    align?: 'left' | 'right';
+}
+export type ReportCell = string | number | null;
+export type ReportRow = Record<string, ReportCell>;
+export interface ReportTable {
+    id: string;
+    title?: string;
+    columns: ReportColumn[];
+    rows: ReportRow[];
+    /** Optional totals row, rendered last (CSV, HTML and PDF all include it). */
+    footer?: ReportRow;
+}
+export interface ReportResult {
+    kind: ReportKind;
+    title: string;
+    documentId: string;
+    /** `live`, `snapshot:<id>` or `version:<id>`. */
+    source: string;
+    options: Record<string, unknown>;
+    tables: ReportTable[];
+    /** Set when the report does not apply (e.g. present-progressive in a language without the construction). */
+    notice?: string;
+}
+export interface ReportKindInfo {
+    kind: ReportKind;
+    featureId: string;
+    title: string;
+    /** False until the report is built; running it answers 501 `REPORT_KIND_UNAVAILABLE`. */
+    available: boolean;
+    unavailableReason?: string;
+    options: ReportOptionDef[];
+    /** Column ids of the main table(s), in order. */
+    columns: ReportColumn[];
+    formats: readonly ReportFormat[];
+}
+interface ReportDef {
+    featureId: string;
+    title: string;
+    options: ReportOptionDef[];
+    columns: ReportColumn[];
+    unavailable?: string;
+}
+/** Column and option declarations. The tables a report returns use exactly these column ids. */
+export declare const REPORT_DEFS: Record<ReportKind, ReportDef>;
+export declare function reportKindInfos(): ReportKindInfo[];
+export declare const isReportKind: (v: unknown) => v is ReportKind;
+export type ParsedReportOptions = {
+    ok: true;
+    options: Record<string, unknown>;
+} | {
+    ok: false;
+    issues: {
+        path: string;
+        message: string;
+    }[];
+};
+/** Validates and defaults `raw` against the kind's option declarations (unknown keys are refused). */
+export declare function parseReportOptions(kind: ReportKind, raw: unknown): ParsedReportOptions;
+/** `GET /documents/:did/reports/:kind?source=&options=<json>`. */
+export declare const reportGetQuerySchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ReportGetQuery = z.infer<typeof reportGetQuerySchema>;
+/** `POST /documents/:did/reports`. `json` answers the result; the other formats a `report.render` job. */
+export declare const reportCreateSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        scene: "scene";
+        script: "script";
+        structure: "structure";
+        character: "character";
+        dialogue: "dialogue";
+        text: "text";
+        location: "location";
+        cast: "cast";
+        notes: "notes";
+        synopsis: "synopsis";
+        revisions: "revisions";
+        tags: "tags";
+        statistics: "statistics";
+        inclusivity: "inclusivity";
+        presentProgressive: "presentProgressive";
+        dayOutOfDays: "dayOutOfDays";
+        shotList: "shotList";
+        characterArcs: "characterArcs";
+    }>;
+    source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"live">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"snapshot">;
+        snapshotId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"version">;
+        versionId: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        csv: "csv";
+        pdf: "pdf";
+        html: "html";
+    }>>;
+}, z.core.$strip>;
+export type ReportCreateRequest = z.infer<typeof reportCreateSchema>;
+/** The `input` of a `report.render` job (`sources[0]` is the document). */
+export declare const reportRenderInputSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        scene: "scene";
+        script: "script";
+        structure: "structure";
+        character: "character";
+        dialogue: "dialogue";
+        text: "text";
+        location: "location";
+        cast: "cast";
+        notes: "notes";
+        synopsis: "synopsis";
+        revisions: "revisions";
+        tags: "tags";
+        statistics: "statistics";
+        inclusivity: "inclusivity";
+        presentProgressive: "presentProgressive";
+        dayOutOfDays: "dayOutOfDays";
+        shotList: "shotList";
+        characterArcs: "characterArcs";
+    }>;
+    source: z.ZodDefault<z.ZodString>;
+    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        csv: "csv";
+        pdf: "pdf";
+        html: "html";
+    }>>;
+}, z.core.$strip>;
+export type ReportRenderInput = z.infer<typeof reportRenderInputSchema>;
+export declare const cellText: (v: ReportCell) => string;
+/** CSV of every table (a title line and a blank line between tables when there is more than one). RFC 4180 quoting, CRLF. */
+export declare function reportToCsv(result: Pick<ReportResult, 'tables'>): string;
+export {};