@setzkasten-cms/core 0.4.2

package/LICENSE

@@ -0,0 +1,37 @@
+Setzkasten Community License
+
+Copyright (c) 2026 Lilapixel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, merge, publish, and distribute the Software, subject to the
+following conditions:
+
+1. The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+2. The Software may not be used for commercial purposes without a separate
+   commercial license from the copyright holder. "Commercial purposes" means
+   any use of the Software that is primarily intended for or directed toward
+   commercial advantage or monetary compensation. This includes, but is not
+   limited to:
+   - Using the Software to manage content for a commercial website or product
+   - Offering the Software as part of a paid service
+   - Using the Software within a for-profit organization
+
+3. Non-commercial use is permitted without restriction. This includes:
+   - Personal projects
+   - Open source projects
+   - Educational and academic use
+   - Non-profit organizations
+
+4. A commercial license ("Enterprise License") may be obtained by contacting
+   Lilapixel at hello@lilapixel.de.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-IL2PWN4R.js

@@ -0,0 +1,142 @@
+// src/schema/define-config.ts
+function defineSection(options) {
+  return Object.freeze({
+    label: options.label,
+    icon: options.icon,
+    fields: options.fields
+  });
+}
+function defineCollection(options) {
+  return Object.freeze({
+    label: options.label,
+    path: options.path,
+    slugField: options.slugField,
+    fields: options.fields
+  });
+}
+function defineConfig(config) {
+  return Object.freeze(config);
+}
+
+// src/fields/factories.ts
+var f = {
+  text(options) {
+    return Object.freeze({
+      type: "text",
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? "",
+      required: options.required ?? false,
+      multiline: options.multiline ?? false,
+      placeholder: options.placeholder,
+      maxLength: options.maxLength,
+      pattern: options.pattern,
+      formatting: options.formatting ?? false
+    });
+  },
+  number(options) {
+    return Object.freeze({
+      type: "number",
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? 0,
+      required: options.required ?? false,
+      min: options.min,
+      max: options.max,
+      step: options.step,
+      slider: options.slider ?? false
+    });
+  },
+  boolean(options) {
+    return Object.freeze({
+      type: "boolean",
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? false
+    });
+  },
+  select(options) {
+    return Object.freeze({
+      type: "select",
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? options.options[0]?.value ?? "",
+      required: options.required ?? false,
+      options: Object.freeze(options.options),
+      multi: options.multi ?? false
+    });
+  },
+  icon(options) {
+    return Object.freeze({
+      type: "icon",
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? "",
+      required: options.required ?? false
+    });
+  },
+  image(options) {
+    return Object.freeze({
+      type: "image",
+      label: options.label,
+      description: options.description,
+      required: options.required ?? false,
+      directory: options.directory,
+      accept: Object.freeze(options.accept ?? ["webp", "jpg", "png"]),
+      maxSize: options.maxSize,
+      filenameStrategy: options.filenameStrategy ?? "original"
+    });
+  },
+  array(itemField, options) {
+    return Object.freeze({
+      type: "array",
+      label: options.label,
+      description: options.description,
+      required: options.required ?? false,
+      itemField,
+      minItems: options.minItems,
+      maxItems: options.maxItems,
+      itemLabel: options.itemLabel
+    });
+  },
+  object(fields, options) {
+    return Object.freeze({
+      type: "object",
+      label: options.label,
+      description: options.description,
+      required: options.required ?? false,
+      fields,
+      collapsible: options.collapsible ?? false
+    });
+  },
+  color(options) {
+    return Object.freeze({
+      type: "color",
+      label: options.label,
+      description: options.description,
+      defaultValue: options.defaultValue ?? "#000000",
+      presets: Object.freeze(options.presets ?? [])
+    });
+  },
+  /**
+   * Override field – wraps a set of fields with an "active" checkbox.
+   * When inactive, the override fields are hidden and don't affect output.
+   * This replaces Keystatic's DOM-hack approach with a native schema concept.
+   */
+  override(fields, options) {
+    return Object.freeze({
+      type: "override",
+      label: options.label,
+      description: options.description,
+      defaultValue: { active: false },
+      fields
+    });
+  }
+};
+
+export {
+  defineSection,
+  defineCollection,
+  defineConfig,
+  f
+};

package/dist/define-config-bJ65Zaui.d.ts

@@ -0,0 +1,209 @@
+/** Discriminator for all field types */
+type FieldType = 'text' | 'number' | 'boolean' | 'select' | 'icon' | 'image' | 'array' | 'object' | 'conditional' | 'color' | 'override';
+/** Path to a field in a nested schema (e.g. ['items', 0, 'title']) */
+type FieldPath = ReadonlyArray<string | number>;
+/**
+ * Base field definition. The phantom type TValue carries the runtime value type
+ * through the type system without ever being assigned at runtime.
+ */
+interface FieldDefinition<TType extends FieldType = FieldType, TValue = unknown> {
+    readonly type: TType;
+    readonly label: string;
+    readonly description?: string;
+    readonly defaultValue?: TValue;
+    readonly required?: boolean;
+    readonly _phantom?: TValue;
+}
+interface TextFieldOptions {
+    label: string;
+    description?: string;
+    defaultValue?: string;
+    required?: boolean;
+    multiline?: boolean;
+    placeholder?: string;
+    maxLength?: number;
+    pattern?: RegExp;
+    /** Enable inline formatting (bold, italic, strike, links). Output is HTML. */
+    formatting?: boolean;
+}
+interface TextFieldDef extends FieldDefinition<'text', string> {
+    readonly multiline: boolean;
+    readonly placeholder?: string;
+    readonly maxLength?: number;
+    readonly pattern?: RegExp;
+    readonly formatting: boolean;
+}
+interface NumberFieldOptions {
+    label: string;
+    description?: string;
+    defaultValue?: number;
+    required?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    slider?: boolean;
+}
+interface NumberFieldDef extends FieldDefinition<'number', number> {
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly slider: boolean;
+}
+interface BooleanFieldOptions {
+    label: string;
+    description?: string;
+    defaultValue?: boolean;
+}
+interface BooleanFieldDef extends FieldDefinition<'boolean', boolean> {
+}
+interface SelectOption {
+    readonly label: string;
+    readonly value: string;
+    readonly icon?: string;
+}
+interface SelectFieldOptions {
+    label: string;
+    description?: string;
+    defaultValue?: string;
+    required?: boolean;
+    options: readonly SelectOption[];
+    multi?: boolean;
+}
+interface SelectFieldDef extends FieldDefinition<'select', string> {
+    readonly options: readonly SelectOption[];
+    readonly multi: boolean;
+}
+interface IconFieldOptions {
+    label: string;
+    description?: string;
+    defaultValue?: string;
+    required?: boolean;
+}
+interface IconFieldDef extends FieldDefinition<'icon', string> {
+}
+interface ImageFieldOptions {
+    label: string;
+    description?: string;
+    required?: boolean;
+    directory: string;
+    accept?: readonly string[];
+    maxSize?: string;
+    filenameStrategy?: 'original' | 'slugified' | 'custom';
+}
+interface ImageValue {
+    readonly path: string;
+    readonly alt?: string;
+}
+interface ImageFieldDef extends FieldDefinition<'image', ImageValue> {
+    readonly directory: string;
+    readonly accept: readonly string[];
+    readonly maxSize?: string;
+    readonly filenameStrategy: 'original' | 'slugified' | 'custom';
+}
+interface ArrayFieldOptions {
+    label: string;
+    description?: string;
+    required?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    itemLabel?: (item: unknown, index: number) => string;
+}
+interface ArrayFieldDef<TItem extends FieldDefinition = FieldDefinition> extends FieldDefinition<'array', InferFieldValue<TItem>[]> {
+    readonly itemField: TItem;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly itemLabel?: (item: unknown, index: number) => string;
+}
+interface ObjectFieldOptions {
+    label: string;
+    description?: string;
+    required?: boolean;
+    collapsible?: boolean;
+}
+type FieldRecord = Record<string, FieldDefinition>;
+interface ObjectFieldDef<TFields extends FieldRecord = FieldRecord> extends FieldDefinition<'object', InferSchemaValues<TFields>> {
+    readonly fields: TFields;
+    readonly collapsible: boolean;
+}
+interface ColorFieldOptions {
+    label: string;
+    description?: string;
+    defaultValue?: string;
+    presets?: readonly string[];
+}
+interface ColorFieldDef extends FieldDefinition<'color', string> {
+    readonly presets: readonly string[];
+}
+interface OverrideFieldOptions {
+    label: string;
+    description?: string;
+}
+interface OverrideFieldDef<TFields extends FieldRecord = FieldRecord> extends FieldDefinition<'override', {
+    active: boolean;
+} & Partial<InferSchemaValues<TFields>>> {
+    readonly fields: TFields;
+}
+/** Extract the runtime value type from a FieldDefinition */
+type InferFieldValue<F> = F extends FieldDefinition<infer _T, infer V> ? V : never;
+/** Infer all values from a schema record */
+type InferSchemaValues<S extends FieldRecord> = {
+    [K in keyof S]: InferFieldValue<S[K]>;
+};
+/** Union of all concrete field definitions */
+type AnyFieldDef = TextFieldDef | NumberFieldDef | BooleanFieldDef | SelectFieldDef | IconFieldDef | ImageFieldDef | ArrayFieldDef | ObjectFieldDef | ColorFieldDef | OverrideFieldDef;
+
+interface SectionDefinition<TFields extends FieldRecord = FieldRecord> {
+    readonly label: string;
+    readonly icon?: string;
+    readonly fields: TFields;
+}
+declare function defineSection<TFields extends FieldRecord>(options: {
+    label: string;
+    icon?: string;
+    fields: TFields;
+}): SectionDefinition<TFields>;
+interface ProductDefinition {
+    readonly label: string;
+    readonly sections: Record<string, SectionDefinition>;
+}
+interface CollectionDefinition<TFields extends FieldRecord = FieldRecord> {
+    readonly label: string;
+    readonly path: string;
+    readonly slugField: string;
+    readonly fields: TFields;
+}
+declare function defineCollection<TFields extends FieldRecord>(options: {
+    label: string;
+    path: string;
+    slugField: string;
+    fields: TFields;
+}): CollectionDefinition<TFields>;
+interface StorageConfig {
+    readonly kind: 'github' | 'local';
+    readonly repo?: string;
+    readonly branch?: string;
+}
+interface AuthConfig {
+    readonly providers: readonly ('github' | 'google' | 'email')[];
+    readonly allowedEmails?: readonly string[];
+}
+interface ThemeConfig {
+    readonly primaryColor: string;
+    readonly logo?: string;
+    readonly brandName?: string;
+}
+interface IconsConfig {
+    /** Icon sets to enable. Default: ['lucide'] */
+    readonly sets: readonly string[];
+}
+interface SetzKastenConfig {
+    readonly storage: StorageConfig;
+    readonly auth: AuthConfig;
+    readonly theme?: ThemeConfig;
+    readonly icons?: IconsConfig;
+    readonly products: Record<string, ProductDefinition>;
+    readonly collections?: Record<string, CollectionDefinition>;
+}
+declare function defineConfig(config: SetzKastenConfig): SetzKastenConfig;
+
+export { type ArrayFieldOptions as A, type BooleanFieldOptions as B, type ColorFieldOptions as C, type ThemeConfig as D, defineCollection as E, type FieldDefinition as F, defineConfig as G, defineSection as H, type IconFieldOptions as I, type NumberFieldOptions as N, type ObjectFieldOptions as O, type ProductDefinition as P, type SelectFieldOptions as S, type TextFieldOptions as T, type TextFieldDef as a, type NumberFieldDef as b, type BooleanFieldDef as c, type SelectFieldDef as d, type IconFieldDef as e, type ImageFieldOptions as f, type ImageFieldDef as g, type ArrayFieldDef as h, type FieldRecord as i, type ObjectFieldDef as j, type ColorFieldDef as k, type OverrideFieldOptions as l, type OverrideFieldDef as m, type FieldPath as n, type AnyFieldDef as o, type AuthConfig as p, type CollectionDefinition as q, type FieldType as r, type IconsConfig as s, type ImageValue as t, type InferFieldValue as u, type InferSchemaValues as v, type SectionDefinition as w, type SelectOption as x, type SetzKastenConfig as y, type StorageConfig as z };

package/dist/index.d.ts

@@ -0,0 +1,261 @@
+import { T as TextFieldOptions, a as TextFieldDef, N as NumberFieldOptions, b as NumberFieldDef, B as BooleanFieldOptions, c as BooleanFieldDef, S as SelectFieldOptions, d as SelectFieldDef, I as IconFieldOptions, e as IconFieldDef, f as ImageFieldOptions, g as ImageFieldDef, F as FieldDefinition, A as ArrayFieldOptions, h as ArrayFieldDef, i as FieldRecord, O as ObjectFieldOptions, j as ObjectFieldDef, C as ColorFieldOptions, k as ColorFieldDef, l as OverrideFieldOptions, m as OverrideFieldDef, n as FieldPath } from './define-config-bJ65Zaui.js';
+export { o as AnyFieldDef, p as AuthConfig, q as CollectionDefinition, r as FieldType, s as IconsConfig, t as ImageValue, u as InferFieldValue, v as InferSchemaValues, P as ProductDefinition, w as SectionDefinition, x as SelectOption, y as SetzKastenConfig, z as StorageConfig, D as ThemeConfig, E as defineCollection, G as defineConfig, H as defineSection } from './define-config-bJ65Zaui.js';
+import { z } from 'zod';
+
+/**
+ * Field factories – the public API for defining content schemas.
+ *
+ * Each factory returns a frozen FieldDefinition object with a discriminated
+ * `type` property. The phantom type parameter carries the runtime value type
+ * through the type system for end-to-end inference.
+ */
+declare const f: {
+    readonly text: (options: TextFieldOptions) => TextFieldDef;
+    readonly number: (options: NumberFieldOptions) => NumberFieldDef;
+    readonly boolean: (options: BooleanFieldOptions) => BooleanFieldDef;
+    readonly select: (options: SelectFieldOptions) => SelectFieldDef;
+    readonly icon: (options: IconFieldOptions) => IconFieldDef;
+    readonly image: (options: ImageFieldOptions) => ImageFieldDef;
+    readonly array: <TItem extends FieldDefinition>(itemField: TItem, options: ArrayFieldOptions) => ArrayFieldDef<TItem>;
+    readonly object: <TFields extends FieldRecord>(fields: TFields, options: ObjectFieldOptions) => ObjectFieldDef<TFields>;
+    readonly color: (options: ColorFieldOptions) => ColorFieldDef;
+    /**
+     * Override field – wraps a set of fields with an "active" checkbox.
+     * When inactive, the override fields are hidden and don't affect output.
+     * This replaces Keystatic's DOM-hack approach with a native schema concept.
+     */
+    readonly override: <TFields extends FieldRecord>(fields: TFields, options: OverrideFieldOptions) => OverrideFieldDef<TFields>;
+};
+
+/**
+ * Generates a Zod schema from a FieldDefinition.
+ * This is the single source of truth for validation – Zod schemas are derived
+ * from field definitions, never written by hand.
+ */
+declare function fieldToZod(field: FieldDefinition): z.ZodType;
+/**
+ * Convert an entire field record (schema) to a Zod object schema.
+ */
+declare function schemaToZod(fields: FieldRecord): z.ZodObject<Record<string, z.ZodType>>;
+
+/**
+ * Strategy interface for field serialization.
+ * Each field type defines how it converts between editor values and stored format.
+ */
+interface FieldSerializer<TValue = unknown, TSerialized = unknown> {
+    serialize(value: TValue): TSerialized;
+    deserialize(raw: TSerialized): TValue;
+}
+/**
+ * Registry of serializers keyed by field type.
+ */
+type SerializerRegistry = Record<string, FieldSerializer>;
+/**
+ * Serialize an entire schema's values to a flat JSON object.
+ */
+declare function serializeEntry(fields: FieldRecord, values: Record<string, unknown>, registry: SerializerRegistry): Record<string, unknown>;
+/**
+ * Deserialize a stored JSON object back to editor values.
+ */
+declare function deserializeEntry(fields: FieldRecord, raw: Record<string, unknown>, registry: SerializerRegistry): Record<string, unknown>;
+
+/**
+ * Default JSON serializer registry.
+ * Compatible with Keystatic's JSON output format.
+ */
+declare const jsonSerializerRegistry: SerializerRegistry;
+
+/**
+ * Command pattern – all mutations go through commands.
+ * This gives undo/redo for free.
+ */
+interface Command {
+    execute(): void;
+    undo(): void;
+    describe(): string;
+}
+/**
+ * Command history – manages undo/redo stacks.
+ */
+interface CommandHistory {
+    execute(command: Command): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+}
+declare function createCommandHistory(): CommandHistory;
+
+type ContentEvent = {
+    readonly type: 'field-changed';
+    readonly path: FieldPath;
+    readonly value: unknown;
+} | {
+    readonly type: 'entry-saved';
+    readonly collection: string;
+    readonly slug: string;
+} | {
+    readonly type: 'entry-deleted';
+    readonly collection: string;
+    readonly slug: string;
+} | {
+    readonly type: 'entry-loaded';
+    readonly collection: string;
+    readonly slug: string;
+};
+type ContentEventType = ContentEvent['type'];
+type Unsubscribe = () => void;
+/**
+ * Observer pattern – decoupled communication between form state and preview engine.
+ */
+interface ContentEventBus {
+    emit(event: ContentEvent): void;
+    on<T extends ContentEventType>(type: T, handler: (event: Extract<ContentEvent, {
+        type: T;
+    }>) => void): Unsubscribe;
+}
+declare function createEventBus(): ContentEventBus;
+
+type SetzKastenError = ValidationError | ConflictError | RateLimitError | AuthError | NetworkError | NotFoundError | SerializationError;
+interface BaseError {
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly timestamp: number;
+}
+interface ValidationError extends BaseError {
+    readonly type: 'validation';
+    readonly fieldPath: FieldPath;
+    readonly rule: string;
+}
+interface ConflictError extends BaseError {
+    readonly type: 'conflict';
+}
+interface RateLimitError extends BaseError {
+    readonly type: 'rate-limit';
+    readonly retryAfter: number;
+    readonly remaining: number;
+}
+interface AuthError extends BaseError {
+    readonly type: 'auth';
+}
+interface NetworkError extends BaseError {
+    readonly type: 'network';
+}
+interface NotFoundError extends BaseError {
+    readonly type: 'not-found';
+    readonly path: string;
+}
+interface SerializationError extends BaseError {
+    readonly type: 'serialization';
+    readonly path?: string;
+}
+type Result<T, E = SetzKastenError> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: E;
+};
+declare function ok<T>(value: T): Result<T, never>;
+declare function err<E>(error: E): Result<never, E>;
+declare function validationError(fieldPath: FieldPath, rule: string, message: string): ValidationError;
+declare function conflictError(message: string): ConflictError;
+declare function rateLimitError(retryAfter: number, remaining: number): RateLimitError;
+declare function authError(message: string): AuthError;
+declare function networkError(message: string, cause?: unknown): NetworkError;
+declare function notFoundError(path: string): NotFoundError;
+declare function serializationError(message: string, path?: string): SerializationError;
+
+interface EntryData {
+    readonly content: Record<string, unknown>;
+    readonly sha?: string;
+}
+interface Asset {
+    readonly path: string;
+    readonly content: Uint8Array;
+    readonly mimeType: string;
+}
+interface CommitResult {
+    readonly sha: string;
+    readonly message: string;
+    readonly url?: string;
+}
+interface TreeNode {
+    readonly path: string;
+    readonly type: 'file' | 'dir';
+    readonly sha?: string;
+}
+interface EntryListItem {
+    readonly slug: string;
+    readonly name: string;
+}
+/**
+ * Repository pattern: abstracts content storage.
+ * Implemented by github-adapter (and potentially local-filesystem, GitLab, etc.)
+ */
+interface ContentRepository {
+    /** List all entries in a collection/singleton directory */
+    listEntries(collection: string): Promise<Result<EntryListItem[]>>;
+    /** Read a single entry's content */
+    getEntry(collection: string, slug: string): Promise<Result<EntryData>>;
+    /** Save an entry with optional assets (images). Creates a single atomic commit. */
+    saveEntry(collection: string, slug: string, data: EntryData, assets?: Asset[]): Promise<Result<CommitResult>>;
+    /** Delete an entry */
+    deleteEntry(collection: string, slug: string): Promise<Result<CommitResult>>;
+    /** Get the full repository tree (for navigation) */
+    getTree(ref?: string): Promise<Result<TreeNode[]>>;
+}
+
+interface AuthUser {
+    readonly id: string;
+    readonly email: string;
+    readonly name?: string;
+    readonly avatarUrl?: string;
+    readonly provider: 'github' | 'google' | 'email';
+}
+interface AuthSession {
+    readonly user: AuthUser;
+    readonly expiresAt: number;
+}
+/**
+ * Auth provider port – abstracts authentication.
+ * Determines WHO can access the CMS, separate from HOW content is committed.
+ */
+interface AuthProvider {
+    /** Get current session (null if not authenticated) */
+    getSession(): Promise<Result<AuthSession | null>>;
+    /** Get the OAuth redirect URL for login */
+    getLoginUrl(provider: 'github' | 'google' | 'email'): string;
+    /** Exchange auth callback for session */
+    handleCallback(code: string, provider: string): Promise<Result<AuthSession>>;
+    /** End session */
+    logout(): Promise<void>;
+}
+
+interface AssetMetadata {
+    readonly path: string;
+    readonly size: number;
+    readonly mimeType: string;
+    readonly width?: number;
+    readonly height?: number;
+}
+/**
+ * Asset store port – abstracts image/file storage.
+ * Default implementation uses GitHub Contents API.
+ * Could be swapped for S3, Cloudinary, etc.
+ */
+interface AssetStore {
+    /** Upload an asset, preserving the original filename */
+    upload(directory: string, filename: string, content: Uint8Array, mimeType: string): Promise<Result<AssetMetadata>>;
+    /** Delete an asset */
+    delete(path: string): Promise<Result<void>>;
+    /** List assets in a directory */
+    list(directory: string): Promise<Result<AssetMetadata[]>>;
+    /** Get a public URL for an asset (for the deployed website) */
+    getUrl(path: string): string;
+    /** Get a preview URL that works immediately (e.g. raw GitHub URL) */
+    getPreviewUrl?(path: string): string;
+}
+
+export { ArrayFieldDef, type Asset, type AssetMetadata, type AssetStore, type AuthError, type AuthProvider, type AuthSession, type AuthUser, BooleanFieldDef, ColorFieldDef, type Command, type CommandHistory, type CommitResult, type ConflictError, type ContentEvent, type ContentEventBus, type ContentEventType, type ContentRepository, type EntryData, type EntryListItem, FieldDefinition, FieldPath, FieldRecord, type FieldSerializer, IconFieldDef, ImageFieldDef, type NetworkError, type NotFoundError, NumberFieldDef, ObjectFieldDef, OverrideFieldDef, type RateLimitError, type Result, SelectFieldDef, type SerializationError, type SerializerRegistry, type SetzKastenError, TextFieldDef, type TreeNode, type Unsubscribe, type ValidationError, authError, conflictError, createCommandHistory, createEventBus, deserializeEntry, err, f, fieldToZod, jsonSerializerRegistry, networkError, notFoundError, ok, rateLimitError, schemaToZod, serializationError, serializeEntry, validationError };