@tomradex/domain 0.0.0-stage → 0.2.16

package/dist/fields.js

@@ -0,0 +1,104 @@
+import { ITEM_STATUSES } from "./types.js";
+/** The types a user may create. The rest are built-in only. */
+export const CUSTOM_FIELD_TYPES = ["text", "number", "date", "select", "checkbox"];
+/** A checkbox is stored only when ticked; unticked is the absence of a value. */
+export const CHECKED = 1;
+const PRIORITY_NAMES = ["None", "Low", "Medium", "High", "Urgent"];
+const STATUS_NAMES = { backlog: "Backlog", todo: "To Do", doing: "Doing", verifying: "Verifying", done: "Done", cancelled: "Cancelled" };
+const staticOptions = (ids, name) => ids.map((id, rank) => ({ id, name: name(id), description: null, rank }));
+const builtin = (id, name, type, rank, extra = {}) => ({
+    id,
+    projectId: null,
+    name,
+    type,
+    builtin: true,
+    options: extra.options ?? [],
+    optionsFrom: extra.optionsFrom,
+    readonly: extra.readonly ?? false,
+    can: extra.can ?? { filter: true, sort: true, group: type === "select" || type === "item" },
+    rank
+});
+/** The fields every project has, in display order. Ids are reserved: a custom field can never claim one. */
+export const BUILTIN_FIELDS = [
+    builtin("title", "Title", "text", 0, { can: { filter: true, sort: true, group: false } }),
+    builtin("status", "Status", "select", 1, { options: staticOptions(ITEM_STATUSES, (s) => STATUS_NAMES[s]) }),
+    builtin("workType", "Work type", "select", 9, { options: staticOptions(["coding", "general"], (s) => s === "coding" ? "Coding" : "General") }),
+    // Urgent first: the column order a priority board reads in.
+    builtin("priority", "Priority", "select", 2, { options: staticOptions(["4", "3", "2", "1", "0"], (p) => PRIORITY_NAMES[Number(p)]) }),
+    builtin("epic", "Epic", "item", 3, { optionsFrom: "epics" }),
+    builtin("labels", "Labels", "labels", 4, { can: { filter: true, sort: false, group: false } }),
+    builtin("board", "Workstream", "select", 5, { optionsFrom: "boards" }),
+    builtin("updated", "Updated", "date", 6, { readonly: true, can: { filter: true, sort: true, group: false } }),
+    builtin("key", "Key", "number", 7, { readonly: true, can: { filter: false, sort: true, group: false } }),
+    builtin("provenance", "Last write", "select", 8, {
+        readonly: true,
+        options: staticOptions(["human", "ai", "sync", "locked"], (p) => ({ human: "human", ai: "ai", sync: "sync", locked: "human-locked" })[p])
+    })
+];
+export const BUILTIN_FIELD_IDS = new Set(BUILTIN_FIELDS.map((f) => f.id));
+export const isBuiltinFieldId = (id) => BUILTIN_FIELD_IDS.has(id);
+/** The empty-value sentinel a group key uses, and the literal a filter may name. */
+export const EMPTY_KEY = "none";
+const provenanceOf = (item) => item.humanLocked ? "locked" : item.updatedBy.startsWith("ai:") ? "ai" : item.updatedBy.startsWith("sync:") ? "sync" : "human";
+/**
+ * The raw value of a field on an item, built-in or custom. Labels are the one
+ * multi-valued field; everything else is a scalar or null.
+ */
+export function fieldValueOf(item, fieldId) {
+    switch (fieldId) {
+        case "title":
+            return item.title;
+        case "status":
+            return item.status;
+        case "workType":
+            return item.workType;
+        case "priority":
+            return String(item.priority);
+        case "epic":
+            return item.parentId;
+        case "labels":
+            return item.labels;
+        case "board":
+            return item.boardId;
+        case "updated":
+            return item.updatedAt;
+        case "key":
+            return item.keyNum;
+        case "provenance":
+            return provenanceOf(item);
+        default:
+            return item.fields[fieldId] ?? null;
+    }
+}
+/** Which column or swimlane an item falls into for a groupable field. */
+export function groupKeyOf(item, fieldId) {
+    const v = fieldValueOf(item, fieldId);
+    if (v === null || Array.isArray(v))
+        return EMPTY_KEY;
+    return String(v);
+}
+/** The patch a drop into `key` writes, for a groupable field; null when the field cannot be written. */
+export function patchForGroup(fieldId, key, def) {
+    const empty = key === EMPTY_KEY;
+    switch (fieldId) {
+        case "status":
+            return empty ? null : { status: key };
+        case "workType":
+            return key === "coding" || key === "general" ? { workType: key } : null;
+        case "priority":
+            return empty ? null : { priority: Number(key) };
+        case "epic":
+            return { parentId: empty ? null : key };
+        case "board":
+            return empty ? null : { boardId: key };
+        default:
+            if (!def || def.builtin)
+                return null;
+            if (def.type === "select")
+                return { fields: { [fieldId]: empty ? null : key } };
+            if (def.type === "checkbox")
+                return { fields: { [fieldId]: empty ? null : CHECKED } };
+            return null;
+    }
+}
+//# sourceMappingURL=fields.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./delivery.js";
+export * from "./attachments.js";
+export * from "./errors.js";
+export * from "./schema.js";
+export * from "./derive.js";
+export * from "./fields.js";
+export * from "./query.js";
+export * from "./words.js";
+export * from "./language.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./delivery.js";
+export * from "./attachments.js";
+export * from "./errors.js";
+export * from "./schema.js";
+export * from "./derive.js";
+export * from "./fields.js";
+export * from "./query.js";
+export * from "./words.js";
+export * from "./language.js";
+//# sourceMappingURL=index.js.map

package/dist/language.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Languages as data. English is the source every dictionary translates: a
+ * translation is a set of `namespace → key → template` entries, and an entry
+ * counts only where English has the key and the template asks for the same
+ * values. Everything here is pure, so the main process and the renderer
+ * merge, check and pick languages the same way.
+ */
+/** A BCP 47 language tag: "en", "zh-Hant", "pt-BR". */
+export type LanguageTag = string;
+/** Templates by namespace, then key. */
+export type Dictionaries = Record<string, Record<string, string>>;
+/** The tag in its canonical spelling ("pt-br" → "pt-BR"), or null when it is not a language tag. */
+export declare function canonicalTag(tag: unknown): LanguageTag | null;
+export declare const isLanguageTag: (tag: unknown) => tag is LanguageTag;
+/** Any language a person may be reading in; English for anything that is not a tag ("system", nothing at all). */
+export declare const languageTag: (locale: unknown) => LanguageTag;
+/** The language's English name, for a prompt's "reply in …" line: "Brazilian Portuguese". */
+export declare function languageName(locale: unknown): string;
+/** What a template fills in or keys off: its `{{slot}}`s and the `[[cmd:…]]` chords the interface writes. */
+export declare const slotsOf: (template: string) => string[];
+export declare const sameSlots: (a: string, b: string) => boolean;
+/** The entries of a translation that can stand in for English: keys English has, asking for the values its template does. */
+export declare function usableWords(english: Dictionaries, translated: Dictionaries): Dictionaries;
+export interface LanguageCoverage {
+    /** Entries English has. */
+    total: number;
+    /** Entries translated with the slots English asks for. */
+    translated: number;
+    /** `namespace.key` English has and the translation does not; these read in English. */
+    missing: string[];
+    /** `namespace.key` the translation has and English no longer does; nothing reads them. */
+    stale: string[];
+    /** Entries whose template asks for other values than English's; these read in English. */
+    slotMismatches: {
+        key: string;
+        english: string[];
+        translated: string[];
+    }[];
+}
+/** How much of English a translation covers, and what in it nothing can use. */
+export declare function languageCoverage(english: Dictionaries, translated: Dictionaries): LanguageCoverage;
+/**
+ * The language to show for a system that prefers `system`, among those the
+ * app has: the same tag, else the same language written in the same script —
+ * the system's region first, then the language's plain tag. zh-TW finds
+ * zh-Hant and never zh; pt-PT finds pt-BR when that is all there is.
+ */
+export declare function pickLanguage(system: string | readonly string[] | undefined | null, available: readonly LanguageTag[]): LanguageTag | null;
+//# sourceMappingURL=language.d.ts.map

package/dist/language.js

@@ -0,0 +1,117 @@
+/**
+ * Languages as data. English is the source every dictionary translates: a
+ * translation is a set of `namespace → key → template` entries, and an entry
+ * counts only where English has the key and the template asks for the same
+ * values. Everything here is pure, so the main process and the renderer
+ * merge, check and pick languages the same way.
+ */
+const canonical = new Map();
+/** The tag in its canonical spelling ("pt-br" → "pt-BR"), or null when it is not a language tag. */
+export function canonicalTag(tag) {
+    if (typeof tag !== "string" || !/^[A-Za-z]{2,3}(-[A-Za-z0-9]{1,8})*$/.test(tag))
+        return null;
+    let known = canonical.get(tag);
+    if (known === undefined) {
+        try {
+            known = Intl.getCanonicalLocales(tag)[0] ?? null;
+        }
+        catch {
+            known = null;
+        }
+        canonical.set(tag, known);
+    }
+    return known;
+}
+export const isLanguageTag = (tag) => canonicalTag(tag) !== null;
+/** Any language a person may be reading in; English for anything that is not a tag ("system", nothing at all). */
+export const languageTag = (locale) => canonicalTag(locale) ?? "en";
+// Intl names zh "Chinese"; the app's zh is the simplified script.
+const NAMES = { zh: "Simplified Chinese", "zh-Hant": "Traditional Chinese" };
+/** The language's English name, for a prompt's "reply in …" line: "Brazilian Portuguese". */
+export function languageName(locale) {
+    const tag = languageTag(locale);
+    if (NAMES[tag])
+        return NAMES[tag];
+    try {
+        return new Intl.DisplayNames(["en"], { type: "language" }).of(tag) ?? tag;
+    }
+    catch {
+        return tag;
+    }
+}
+/** What a template fills in or keys off: its `{{slot}}`s and the `[[cmd:…]]` chords the interface writes. */
+export const slotsOf = (template) => [...new Set((template.match(/\{\{\s*\w+\s*\}\}|\[\[cmd:\w+\]\]/g) ?? []).map((s) => s.replace(/\s/g, "")))].sort();
+export const sameSlots = (a, b) => slotsOf(a).join("\0") === slotsOf(b).join("\0");
+/** The entries of a translation that can stand in for English: keys English has, asking for the values its template does. */
+export function usableWords(english, translated) {
+    const out = {};
+    for (const [ns, entries] of Object.entries(translated)) {
+        const source = english[ns];
+        if (!source || typeof entries !== "object" || entries === null)
+            continue;
+        for (const [key, text] of Object.entries(entries)) {
+            if (typeof text !== "string" || typeof source[key] !== "string" || !sameSlots(source[key], text))
+                continue;
+            (out[ns] ??= {})[key] = text;
+        }
+    }
+    return out;
+}
+/** How much of English a translation covers, and what in it nothing can use. */
+export function languageCoverage(english, translated) {
+    const out = { total: 0, translated: 0, missing: [], stale: [], slotMismatches: [] };
+    for (const [ns, entries] of Object.entries(english)) {
+        for (const [key, source] of Object.entries(entries)) {
+            out.total += 1;
+            const text = translated[ns]?.[key];
+            if (typeof text !== "string")
+                out.missing.push(`${ns}.${key}`);
+            else if (!sameSlots(source, text))
+                out.slotMismatches.push({ key: `${ns}.${key}`, english: slotsOf(source), translated: slotsOf(text) });
+            else
+                out.translated += 1;
+        }
+    }
+    for (const [ns, entries] of Object.entries(translated)) {
+        for (const key of Object.keys(entries ?? {}))
+            if (typeof english[ns]?.[key] !== "string")
+                out.stale.push(`${ns}.${key}`);
+    }
+    return out;
+}
+const parts = (tag) => {
+    try {
+        const l = new Intl.Locale(tag).maximize();
+        return { language: l.language, script: l.script, region: l.region };
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * The language to show for a system that prefers `system`, among those the
+ * app has: the same tag, else the same language written in the same script —
+ * the system's region first, then the language's plain tag. zh-TW finds
+ * zh-Hant and never zh; pt-PT finds pt-BR when that is all there is.
+ */
+export function pickLanguage(system, available) {
+    const wanted = (typeof system === "string" ? [system] : (system ?? [])).map((s) => canonicalTag(s.replace(/_/g, "-").split(".")[0])).filter((s) => !!s);
+    const options = available.flatMap((tag) => {
+        const p = parts(tag);
+        return p ? [{ tag, ...p }] : [];
+    });
+    for (const tag of wanted) {
+        const exact = available.find((a) => a.toLowerCase() === tag.toLowerCase());
+        if (exact)
+            return exact;
+        const want = parts(tag);
+        if (!want)
+            continue;
+        const same = options.filter((o) => o.language === want.language && o.script === want.script);
+        const pick = same.find((o) => o.region === want.region && o.tag.includes("-")) ?? same.find((o) => o.tag === want.language) ?? same[0];
+        if (pick)
+            return pick.tag;
+    }
+    return null;
+}
+//# sourceMappingURL=language.js.map

package/dist/query.d.ts

@@ -0,0 +1,73 @@
+import { type FieldDef } from "./fields.js";
+import type { FieldValue, Item } from "./types.js";
+/**
+ * How a view draws the backlog. Board and table group and sort; a graph draws
+ * the edges a plugin contributes. A view is one layout plus one query.
+ */
+export type Layout = "board" | "table" | "graph";
+export declare const LAYOUTS: readonly Layout[];
+/**
+ * `in` / `not-in` take values; a null value means "empty". `contains` is a
+ * case-insensitive substring over text. `gte` / `lte` compare numbers and dates.
+ */
+export type FilterOp = "in" | "not-in" | "contains" | "gte" | "lte";
+export interface FilterClause {
+    field: string;
+    op: FilterOp;
+    values: (FieldValue | null)[];
+}
+export interface SortKey {
+    field: string;
+    dir: "asc" | "desc";
+}
+/**
+ * The stored shape of a view's query and the live shape the bar edits. Empty
+ * `columns` means every key the field has; empty `sortBy` means manual order.
+ */
+export interface ViewQuery {
+    filter: FilterClause[];
+    /** Board layout: the field one column stands for. */
+    columnBy: string | null;
+    /** Visible column keys in order; empty shows them all. */
+    columns: string[];
+    /** Swimlanes on a board, groups in a table. */
+    groupBy: string | null;
+    sortBy: SortKey[];
+    /** Fields drawn on cards and as table columns; empty means the layout's default. */
+    fields: string[];
+    /** WIP cap per column key. Advisory — a drop is never blocked. */
+    wip: Record<string, number>;
+    /** Graph layout: the contributed graph whose edges are drawn. */
+    graph: string | null;
+}
+export declare const EMPTY_QUERY: ViewQuery;
+/** Fill a partially stored query so every consumer sees the full shape. */
+export declare const normalizeQuery: (q: Partial<ViewQuery> | null | undefined) => ViewQuery;
+export interface QueryContext {
+    defs: Map<string, FieldDef>;
+    /** Position of an option in its field's order; used to sort and to order columns. */
+    optionRank(fieldId: string, key: string): number;
+    /** A display name for an option key, for sorting fields whose options have no rank (epics by title). */
+    optionName(fieldId: string, key: string): string;
+}
+/** A `YYYY-MM-DD` bound against an epoch-ms value covers the whole day it names. */
+export declare function dayBound(value: FieldValue | null | undefined, op: "gte" | "lte"): number | null;
+export declare function matchesClause(item: Item, clause: FilterClause): boolean;
+export declare const matchesFilter: (item: Item, filter: FilterClause[]) => boolean;
+/**
+ * The terms of a search: whitespace-separated words, except that a run in
+ * double quotes ("login timeout", “登录 超时”) is one term matched as a whole,
+ * spaces included. A quote with no partner runs to the end of the string.
+ */
+export declare function searchTerms(search: string): string[];
+/** Every term appears, case aside, in the ticket's key, title or body — what the items index matches, plus the key. */
+export declare function matchesSearch(item: Item, terms: string[]): boolean;
+/** A comparable for one sort key: numbers for numeric fields, strings otherwise, null when empty. */
+export declare function sortKeyOf(item: Item, fieldId: string, ctx: QueryContext): number | string | null;
+/** Empty values sort last whichever direction; ties fall through to manual rank, then recency. */
+export declare function compareItems(a: Item, b: Item, sortBy: SortKey[], ctx: QueryContext, rankOf: (item: Item) => number): number;
+/** The keys a groupable field can take, in the field's order, with the empty key last where it applies. */
+export declare function groupSpaceOf(def: FieldDef, options: {
+    id: string;
+}[]): string[];
+//# sourceMappingURL=query.d.ts.map

package/dist/query.js

@@ -0,0 +1,138 @@
+import { CHECKED, EMPTY_KEY, fieldValueOf } from "./fields.js";
+export const LAYOUTS = ["board", "table", "graph"];
+export const EMPTY_QUERY = { filter: [], columnBy: "status", columns: [], groupBy: null, sortBy: [], fields: [], wip: {}, graph: null };
+/** Fill a partially stored query so every consumer sees the full shape. */
+export const normalizeQuery = (q) => ({ ...EMPTY_QUERY, ...(q ?? {}), wip: { ...(q?.wip ?? {}) } });
+const norm = (v) => (v === null ? null : String(v));
+const DAY = 86_400_000;
+/** A `YYYY-MM-DD` bound against an epoch-ms value covers the whole day it names. */
+export function dayBound(value, op) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number")
+        return value;
+    const t = Date.parse(value);
+    if (Number.isNaN(t))
+        return null;
+    return op === "lte" ? t + DAY - 1 : t;
+}
+export function matchesClause(item, clause) {
+    const raw = fieldValueOf(item, clause.field);
+    const values = Array.isArray(raw) ? raw : raw === null ? [] : [raw];
+    switch (clause.op) {
+        case "in": {
+            const wanted = new Set(clause.values.map(norm));
+            if (!values.length)
+                return wanted.has(null);
+            return values.some((v) => wanted.has(String(v)));
+        }
+        case "not-in": {
+            const wanted = new Set(clause.values.map(norm));
+            if (!values.length)
+                return !wanted.has(null);
+            return !values.some((v) => wanted.has(String(v)));
+        }
+        case "contains": {
+            const needle = String(clause.values[0] ?? "").toLowerCase();
+            if (!needle)
+                return true;
+            return values.some((v) => String(v).toLowerCase().includes(needle));
+        }
+        case "gte":
+        case "lte": {
+            if (!values.length)
+                return false;
+            const v = values[0];
+            // A numeric field may be bounded by a date string (Updated); anything else compares like for like.
+            const bound = typeof v === "number" ? dayBound(clause.values[0], clause.op) : (clause.values[0] ?? null);
+            if (bound === null)
+                return false;
+            const cmp = typeof v === "number" && typeof bound === "number" ? v - bound : String(v).localeCompare(String(bound));
+            return clause.op === "gte" ? cmp >= 0 : cmp <= 0;
+        }
+    }
+}
+export const matchesFilter = (item, filter) => filter.every((c) => matchesClause(item, c));
+/**
+ * The terms of a search: whitespace-separated words, except that a run in
+ * double quotes ("login timeout", “登录 超时”) is one term matched as a whole,
+ * spaces included. A quote with no partner runs to the end of the string.
+ */
+export function searchTerms(search) {
+    const out = [];
+    const closer = { '"': '"', "\u201c": "\u201d" };
+    let i = 0;
+    while (i < search.length) {
+        const c = search[i];
+        if (/\s/.test(c)) {
+            i++;
+            continue;
+        }
+        const close = closer[c];
+        if (close) {
+            const end = search.indexOf(close, i + 1);
+            const phrase = (end === -1 ? search.slice(i + 1) : search.slice(i + 1, end)).trim();
+            if (phrase)
+                out.push(phrase);
+            i = end === -1 ? search.length : end + 1;
+            continue;
+        }
+        let j = i;
+        while (j < search.length && !/\s/.test(search[j]))
+            j++;
+        out.push(search.slice(i, j));
+        i = j;
+    }
+    return out;
+}
+/** Every term appears, case aside, in the ticket's key, title or body — what the items index matches, plus the key. */
+export function matchesSearch(item, terms) {
+    if (!terms.length)
+        return true;
+    const text = `${item.key} ${item.title} ${item.body ?? ""}`.toLowerCase();
+    return terms.every((term) => text.includes(term.toLowerCase()));
+}
+/** A comparable for one sort key: numbers for numeric fields, strings otherwise, null when empty. */
+export function sortKeyOf(item, fieldId, ctx) {
+    const raw = fieldValueOf(item, fieldId);
+    if (raw === null || Array.isArray(raw))
+        return null;
+    const def = ctx.defs.get(fieldId);
+    if (!def)
+        return null;
+    if (def.type === "select")
+        return ctx.optionRank(fieldId, String(raw));
+    if (def.type === "item")
+        return ctx.optionName(fieldId, String(raw)).toLowerCase();
+    if (def.type === "text")
+        return String(raw).toLowerCase();
+    return raw;
+}
+/** Empty values sort last whichever direction; ties fall through to manual rank, then recency. */
+export function compareItems(a, b, sortBy, ctx, rankOf) {
+    for (const key of sortBy) {
+        const ka = sortKeyOf(a, key.field, ctx);
+        const kb = sortKeyOf(b, key.field, ctx);
+        if (ka === kb)
+            continue;
+        if (ka === null)
+            return 1;
+        if (kb === null)
+            return -1;
+        const cmp = typeof ka === "number" && typeof kb === "number" ? ka - kb : String(ka).localeCompare(String(kb));
+        if (cmp !== 0)
+            return key.dir === "desc" ? -cmp : cmp;
+    }
+    return rankOf(a) - rankOf(b) || b.updatedAt - a.updatedAt;
+}
+/** The keys a groupable field can take, in the field's order, with the empty key last where it applies. */
+export function groupSpaceOf(def, options) {
+    if (def.type === "checkbox")
+        return [String(CHECKED), EMPTY_KEY];
+    const keys = options.map((o) => o.id);
+    // Total fields: every item has a status, a priority, a provenance and a workstream.
+    if (def.id === "status" || def.id === "priority" || def.id === "provenance" || def.id === "board")
+        return keys;
+    return [...keys, EMPTY_KEY];
+}
+//# sourceMappingURL=query.js.map

package/dist/schema.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+export declare const itemKindSchema: z.ZodEnum<{
+    epic: "epic";
+    ticket: "ticket";
+}>;
+export declare const workTypeSchema: z.ZodEnum<{
+    coding: "coding";
+    general: "general";
+}>;
+export declare const itemStatusSchema: z.ZodEnum<{
+    backlog: "backlog";
+    todo: "todo";
+    doing: "doing";
+    verifying: "verifying";
+    done: "done";
+    cancelled: "cancelled";
+}>;
+export declare const prioritySchema: z.ZodLiteral<0 | 1 | 2 | 3 | 4>;
+export declare const listItemsFilterSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    boardId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        todo: "todo";
+        doing: "doing";
+        verifying: "verifying";
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        epic: "epic";
+        ticket: "ticket";
+    }>>;
+    workType: z.ZodOptional<z.ZodEnum<{
+        coding: "coding";
+        general: "general";
+    }>>;
+    priority: z.ZodOptional<z.ZodLiteral<0 | 1 | 2 | 3 | 4>>;
+    label: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const fieldValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+/** A key set to null clears the value. */
+export declare const fieldsPatchSchema: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+export declare const filterClauseSchema: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        in: "in";
+        "not-in": "not-in";
+        contains: "contains";
+        gte: "gte";
+        lte: "lte";
+    }>;
+    values: z.ZodArray<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export declare const sortKeySchema: z.ZodObject<{
+    field: z.ZodString;
+    dir: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>;
+export declare const createItemSchema: z.ZodObject<{
+    playbookId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        epic: "epic";
+        ticket: "ticket";
+    }>>;
+    workType: z.ZodOptional<z.ZodEnum<{
+        coding: "coding";
+        general: "general";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        todo: "todo";
+        doing: "doing";
+        verifying: "verifying";
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+    priority: z.ZodOptional<z.ZodLiteral<0 | 1 | 2 | 3 | 4>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    projectId: z.ZodOptional<z.ZodString>;
+    boardId: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+}, z.core.$strip>;
+export declare const patchSchema: z.ZodObject<{
+    playbookId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        epic: "epic";
+        ticket: "ticket";
+    }>>;
+    workType: z.ZodOptional<z.ZodEnum<{
+        coding: "coding";
+        general: "general";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        todo: "todo";
+        doing: "doing";
+        verifying: "verifying";
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+    priority: z.ZodOptional<z.ZodLiteral<0 | 1 | 2 | 3 | 4>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rank: z.ZodOptional<z.ZodNumber>;
+    boardId: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schema.d.ts.map