@stonecrop/schema 0.13.7 → 0.13.9

package/dist/src/field.d.ts

@@ -1,4 +1,7 @@
 import { z } from 'zod';
+import type { ColumnSchema } from './column-schema';
+import type { InteractionMode } from './mode';
+import { TableViewConfig } from './table';
 /**
  * Field options - flexible bag for type-specific configuration.
  *
@@ -30,14 +33,99 @@ export declare const FieldValidation: z.ZodObject<{
  */
 export type FieldValidation = z.infer<typeof FieldValidation>;
 /**
- * Unified field metadata - the single source of truth for field definitions.
- * Works for both forms (AForm) and tables (ATable).
- *
- * Core principle: "Text" is "Text" regardless of rendering context.
- *
+ * A field that holds a scalar value, a link to another record, or a select choice.
+ * The most common kind of field. `fieldtype` determines the default component and behavior.
+ * @public
+ */
+export interface ValueField {
+    /** Discriminator — identifies this as a value-holding field */
+    kind: 'field';
+    /** Unique identifier for this field within its doctype */
+    fieldname: string;
+    /** Semantic field type — determines behavior and default rendering component */
+    fieldtype: string;
+    /** Vue component to render this field. Derived from `fieldtype` when absent. */
+    component?: string;
+    /** Human-readable label */
+    label?: string;
+    /** CSS width (e.g. `"40ch"`, `"200px"`) */
+    width?: string;
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right' | 'start' | 'end';
+    /** Whether the field is editable in table cell context */
+    edit?: boolean;
+    /** Input mask pattern or serialized function */
+    mask?: string;
+    /** Per-field interaction mode override */
+    mode?: InteractionMode;
+    /** Type-specific options: Link target slug, Select choices, Decimal precision config, etc. */
+    options?: FieldOptions;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Whether the field is read-only */
+    readOnly?: boolean;
+    /** Whether the field is hidden from the UI */
+    hidden?: boolean;
+    /** Default value for new records */
+    default?: unknown;
+    /** Validation configuration */
+    validation?: FieldValidation;
+    /** Cardinality for Link fields — authoritative value on LinkDeclaration takes precedence */
+    cardinality?: 'atMostOne' | 'one' | 'noneOrMany' | 'atLeastOne';
+}
+/**
+ * A layout container that groups other fields. Resolves to a nested AForm.
+ * @public
+ */
+export interface FieldsetField {
+    /** Discriminator — identifies this as a fieldset container */
+    kind: 'fieldset';
+    /** Unique identifier for this fieldset within its doctype */
+    fieldname: string;
+    /** Vue component to render this fieldset. Defaults to `'AFieldset'` in resolveSchema. */
+    component?: string;
+    /** Human-readable label for the fieldset legend */
+    label?: string;
+    /** Whether the fieldset can be collapsed */
+    collapsible?: boolean;
+    /** Interaction mode for all children inside this fieldset */
+    mode?: InteractionMode;
+    /** Nested field definitions — resolved recursively by resolveSchema */
+    schema: DoctypeField[];
+}
+/**
+ * An inline table whose columns are defined directly in the schema (no linked doctype).
+ * Use when the table data does not warrant a separate doctype.
+ * @public
+ */
+export interface TableField {
+    /** Discriminator — identifies this as an inline table */
+    kind: 'table';
+    /** Unique identifier for this table within its doctype */
+    fieldname: string;
+    /** Vue component to render this table. Defaults to `'ATable'` in resolveSchema. */
+    component?: string;
+    /** Human-readable label */
+    label?: string;
+    /** Column definitions — use ColumnSchema (fieldname key) from \@stonecrop/schema */
+    columns: ColumnSchema[];
+    /** View configuration — defaults to `{ view: 'list' }` in resolveSchema when absent */
+    config?: TableViewConfig;
+    /** Interaction mode for all cells inside this table */
+    mode?: InteractionMode;
+}
+/**
+ * Union of all authoring-time field variants.
+ * Use `kind` to discriminate: `'field'` | `'fieldset'` | `'table'`.
+ * @public
+ */
+export type DoctypeField = ValueField | FieldsetField | TableField;
+/**
+ * Zod runtime validation schema for ValueField.
  * @public
  */
-export declare const FieldMeta: z.ZodObject<{
+export declare const ValueFieldSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"field">;
     fieldname: z.ZodString;
     fieldtype: z.ZodString;
     component: z.ZodOptional<z.ZodString>;
@@ -45,34 +133,91 @@ export declare const FieldMeta: z.ZodObject<{
     width: z.ZodOptional<z.ZodString>;
     align: z.ZodOptional<z.ZodEnum<{
         left: "left";
-        center: "center";
         right: "right";
+        center: "center";
         start: "start";
         end: "end";
     }>>;
+    edit: z.ZodOptional<z.ZodBoolean>;
+    mask: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        edit: "edit";
+        read: "read";
+        display: "display";
+    }>>;
+    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
     required: z.ZodOptional<z.ZodBoolean>;
     readOnly: z.ZodOptional<z.ZodBoolean>;
-    edit: z.ZodOptional<z.ZodBoolean>;
     hidden: z.ZodOptional<z.ZodBoolean>;
-    value: z.ZodOptional<z.ZodUnknown>;
     default: z.ZodOptional<z.ZodUnknown>;
-    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    validation: z.ZodOptional<z.ZodObject<{
+        /** Error message to display when validation fails */
+        errorMessage: z.ZodString;
+    }, z.core.$loose>>;
     cardinality: z.ZodOptional<z.ZodEnum<{
-        one: "one";
         atMostOne: "atMostOne";
+        one: "one";
         noneOrMany: "noneOrMany";
         atLeastOne: "atLeastOne";
     }>>;
-    mask: z.ZodOptional<z.ZodString>;
-    validation: z.ZodOptional<z.ZodObject<{
-        /** Error message to display when validation fails */
-        errorMessage: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Zod runtime validation schema for FieldsetField.
+ * Recursive — FieldsetField.schema is validated against DoctypeFieldSchema.
+ * @public
+ */
+export declare const FieldsetFieldSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"fieldset">;
+    fieldname: z.ZodString;
+    component: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    collapsible: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        edit: "edit";
+        read: "read";
+        display: "display";
+    }>>;
+    schema: z.ZodLazy<z.ZodArray<z.ZodType<DoctypeField, unknown, z.core.$ZodTypeInternals<DoctypeField, unknown>>>>;
+}, z.core.$strip>;
+/**
+ * Zod runtime validation schema for TableField.
+ * @public
+ */
+export declare const TableFieldSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"table">;
+    fieldname: z.ZodString;
+    component: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    columns: z.ZodArray<z.ZodObject<{
+        fieldname: z.ZodString;
     }, z.core.$loose>>;
-    schema: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    config: z.ZodOptional<z.ZodObject<{
+        view: z.ZodOptional<z.ZodEnum<{
+            list: "list";
+            uncounted: "uncounted";
+            "list-expansion": "list-expansion";
+            tree: "tree";
+            gantt: "gantt";
+            "tree-gantt": "tree-gantt";
+        }>>;
+        fullWidth: z.ZodOptional<z.ZodBoolean>;
+        defaultTreeExpansion: z.ZodOptional<z.ZodEnum<{
+            root: "root";
+            branch: "branch";
+            leaf: "leaf";
+        }>>;
+        dependencyGraph: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        edit: "edit";
+        read: "read";
+        display: "display";
+    }>>;
 }, z.core.$strip>;
 /**
- * Field metadata type inferred from Zod schema
+ * Zod runtime validation schema for the DoctypeField discriminated union.
+ * Validates all three field variants: `'field'`, `'fieldset'`, `'table'`.
  * @public
  */
-export type FieldMeta = z.infer<typeof FieldMeta>;
+export declare const DoctypeFieldSchema: z.ZodType<DoctypeField, unknown, z.core.$ZodTypeInternals<DoctypeField, unknown>>;
 //# sourceMappingURL=field.d.ts.map

package/dist/src/field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,qGAStB,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,eAAe;IAE1B,qDAAqD;;iBAMpD,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAtBpB,qDAAqD;;;;iBAmHpD,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,qGAStB,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,eAAe;IAE1B,qDAAqD;;iBAMpD,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAM7D;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B,+DAA+D;IAC/D,IAAI,EAAE,OAAO,CAAA;IACb,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAA;IACjB,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAA;IACjB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qBAAqB;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,CAAA;IACrD,0DAA0D;IAC1D,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0CAA0C;IAC1C,IAAI,CAAC,EAAE,eAAe,CAAA;IACtB,8FAA8F;IAC9F,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B,4FAA4F;IAC5F,WAAW,CAAC,EAAE,WAAW,GAAG,KAAK,GAAG,YAAY,GAAG,YAAY,CAAA;CAC/D;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B,8DAA8D;IAC9D,IAAI,EAAE,UAAU,CAAA;IAChB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAA;IACjB,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,mDAAmD;IACnD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,IAAI,CAAC,EAAE,eAAe,CAAA;IACtB,uEAAuE;IACvE,MAAM,EAAE,YAAY,EAAE,CAAA;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B,yDAAyD;IACzD,IAAI,EAAE,OAAO,CAAA;IACb,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAA;IACjB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oFAAoF;IACpF,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,uFAAuF;IACvF,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,uDAAuD;IACvD,IAAI,CAAC,EAAE,eAAe,CAAA;CACtB;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,aAAa,GAAG,UAAU,CAAA;AAkGlE;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;QAlN3B,qDAAqD;;;;;;;;;iBAkNC,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAA8B,CAAA;AAE9D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2B,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,mFAA6B,CAAA"}

package/dist/src/field.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { StonecropFieldType } from './fieldtype';
+import { TableViewConfig } from './table';
 /**
  * Field options - flexible bag for type-specific configuration.
  *
@@ -34,80 +35,115 @@ export const FieldValidation = z
     title: 'FieldValidation',
     description: 'Validation configuration for form fields',
 });
+// ---------------------------------------------------------------------------
+// Zod runtime validation schemas
+// ---------------------------------------------------------------------------
 /**
- * Unified field metadata - the single source of truth for field definitions.
- * Works for both forms (AForm) and tables (ATable).
+ * Infers the `kind` discriminant from the structural properties of a raw field
+ * object, then injects it if absent. This allows authored JSON to omit `kind`
+ * entirely — authors write only `fieldtype`, `schema`, or `columns`.
  *
- * Core principle: "Text" is "Text" regardless of rendering context.
+ * Rules (applied in order):
+ *   has `schema`  → fieldset
+ *   has `columns` → table
+ *   otherwise     → field (value-holding scalar or link)
  *
+ * Objects that already carry `kind` pass through unchanged (backward-compatible).
+ */
+function injectKind(data) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data))
+        return data;
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- safe: non-null, non-array object verified by guards above
+    const obj = data;
+    if ('kind' in obj)
+        return data;
+    if ('schema' in obj)
+        return { kind: 'fieldset', ...obj };
+    if ('columns' in obj)
+        return { kind: 'table', ...obj };
+    return { kind: 'field', ...obj };
+}
+function createDoctypeFieldSchemas() {
+    const ValueFieldSchema = z
+        .object({
+        kind: z.literal('field'),
+        fieldname: z.string().min(1),
+        fieldtype: StonecropFieldType,
+        component: z.string().optional(),
+        label: z.string().optional(),
+        width: z.string().optional(),
+        align: z.enum(['left', 'center', 'right', 'start', 'end']).optional(),
+        edit: z.boolean().optional(),
+        mask: z.string().optional(),
+        mode: z.enum(['edit', 'read', 'display']).optional(),
+        options: FieldOptions.optional(),
+        required: z.boolean().optional(),
+        readOnly: z.boolean().optional(),
+        hidden: z.boolean().optional(),
+        default: z.unknown().optional(),
+        validation: FieldValidation.optional(),
+        cardinality: z.enum(['atMostOne', 'one', 'noneOrMany', 'atLeastOne']).optional(),
+    })
+        .meta({ title: 'ValueField' });
+    const TableFieldSchema = z
+        .object({
+        kind: z.literal('table'),
+        fieldname: z.string().min(1),
+        component: z.string().optional(),
+        label: z.string().optional(),
+        // Validates that each column has fieldname; allows all other ColumnSchema properties
+        columns: z.array(z.object({ fieldname: z.string().min(1) }).passthrough()),
+        config: TableViewConfig.optional(),
+        mode: z.enum(['edit', 'read', 'display']).optional(),
+    })
+        .meta({ title: 'TableField' });
+    // DoctypeFieldSchema must be declared before FieldsetFieldSchema so the z.lazy
+    // callback can close over it. The placeholder is overwritten below; the callback
+    // only runs at parse time, after the real discriminated union is assigned.
+    // See: https://zod.dev/api?id=discriminated-unions#discriminated-unions
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- required by Zod's recursive schema pattern; z.never() placeholder is overwritten before any parse call
+    let DoctypeFieldSchema = z.never();
+    // FieldsetFieldSchema stays as a plain ZodObject (not z.ZodType<T>) so that
+    // z.discriminatedUnion can inspect its 'kind' discriminant property.
+    const FieldsetFieldSchema = z
+        .object({
+        kind: z.literal('fieldset'),
+        fieldname: z.string().min(1),
+        component: z.string().optional(),
+        label: z.string().optional(),
+        collapsible: z.boolean().optional(),
+        mode: z.enum(['edit', 'read', 'display']).optional(),
+        schema: z.lazy(() => DoctypeFieldSchema.array()),
+    })
+        .meta({ title: 'FieldsetField' });
+    const rawUnion = z.discriminatedUnion('kind', [ValueFieldSchema, FieldsetFieldSchema, TableFieldSchema]);
+    // Overwrite the placeholder with the preprocessed schema. Because z.lazy captures
+    // DoctypeFieldSchema by closure reference, the lazy callback in FieldsetFieldSchema
+    // will resolve to this preprocessed version — so nested fieldsets also inject `kind`.
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- ZodPipe output is DoctypeField; same pattern as the z.never() placeholder above
+    DoctypeFieldSchema = z.preprocess(injectKind, rawUnion);
+    return { ValueFieldSchema, TableFieldSchema, FieldsetFieldSchema, DoctypeFieldSchema };
+}
+const schemas = createDoctypeFieldSchemas();
+/**
+ * Zod runtime validation schema for ValueField.
  * @public
  */
-export const FieldMeta = z
-    .object({
-    // === CORE (required) ===
-    /** Unique identifier for the field within its doctype */
-    fieldname: z.string().min(1),
-    /** Semantic field type - determines behavior and default component */
-    fieldtype: StonecropFieldType,
-    // === COMPONENT (optional - derived from fieldtype when not specified) ===
-    /** Vue component to render this field. If not specified, derived from TYPE_MAP */
-    component: z.string().optional(),
-    // === DISPLAY ===
-    /** Human-readable label for the field */
-    label: z.string().optional(),
-    /** Width of the field (CSS value, e.g., "40ch", "200px") */
-    width: z.string().optional(),
-    /** Text alignment within the field */
-    align: z.enum(['left', 'center', 'right', 'start', 'end']).optional(),
-    // === BEHAVIOR ===
-    /** Whether the field is required */
-    required: z.boolean().optional(),
-    /** Whether the field is read-only */
-    readOnly: z.boolean().optional(),
-    /** Whether the field is editable (for table cells) */
-    edit: z.boolean().optional(),
-    /** Whether the field is hidden from the UI */
-    hidden: z.boolean().optional(),
-    // === VALUE ===
-    /** Current value of the field */
-    value: z.unknown().optional(),
-    /** Default value for new records */
-    default: z.unknown().optional(),
-    // === TYPE-SPECIFIC ===
-    /**
-     * Type-specific options:
-     * - Link: target doctype slug ("customer")
-     * - Doctype: child doctype slug ("sales-order-item")
-     * - Select: choices array (["Draft", "Submitted"])
-     * - Decimal: \{ precision, scale \}
-     * - Code: \{ language \}
-     */
-    options: FieldOptions.optional(),
-    /**
-     * Cardinality for Doctype fields:
-     * - 'one': exactly 1 (default)
-     * - 'atMostOne': 0 or 1
-     * - 'noneOrMany': 0 or more
-     * - 'atLeastOne': 1 or more
-     */
-    cardinality: z.enum(['one', 'atMostOne', 'noneOrMany', 'atLeastOne']).optional(),
-    /**
-     * Input mask pattern. Accepts either a plain mask string or a stringified
-     * arrow function that receives `locale` and returns a mask string.
-     *
-     * Plain pattern: `"##/##/####"`
-     *
-     * Function pattern: `"(locale) => locale === 'en-US' ? '(###) ###-####' : '####-######'"`
-     */
-    mask: z.string().optional(),
-    // === VALIDATION ===
-    /** Validation configuration */
-    validation: FieldValidation.optional(),
-    // === LAYOUT ===
-    /** Nested field definitions for Fieldset containers — UI grouping only, no DB column */
-    schema: z.array(z.record(z.string(), z.unknown())).optional(),
-})
-    .meta({
-    title: 'FieldMeta',
-    description: 'Unified field metadata - the single source of truth for field definitions, works for both forms (AForm) and tables (ATable)',
-});
+export const ValueFieldSchema = schemas.ValueFieldSchema;
+/**
+ * Zod runtime validation schema for FieldsetField.
+ * Recursive — FieldsetField.schema is validated against DoctypeFieldSchema.
+ * @public
+ */
+export const FieldsetFieldSchema = schemas.FieldsetFieldSchema;
+/**
+ * Zod runtime validation schema for TableField.
+ * @public
+ */
+export const TableFieldSchema = schemas.TableFieldSchema;
+/**
+ * Zod runtime validation schema for the DoctypeField discriminated union.
+ * Validates all three field variants: `'field'`, `'fieldset'`, `'table'`.
+ * @public
+ */
+export const DoctypeFieldSchema = schemas.DoctypeFieldSchema;

package/dist/src/index.d.ts

@@ -1,5 +1,8 @@
+export type { InteractionMode } from './mode';
+export { TableViewConfig } from './table';
 export { StonecropFieldType, BUILTIN_FIELD_TYPES, TYPE_MAP, getDefaultComponent, resolveComponent, isBuiltinFieldType, type BuiltinFieldType, type FieldTemplate, } from './fieldtype';
-export type { FieldMeta, FieldOptions, FieldValidation } from './field';
+export type { DoctypeField, FieldOptions, FieldValidation, FieldsetField, TableField, ValueField } from './field';
+export { DoctypeFieldSchema, FieldsetFieldSchema, TableFieldSchema, ValueFieldSchema } from './field';
 export type { ActionDefinition, Cardinality, CustomFetch, DataClient, DoctypeContext, DoctypeMeta, DoctypeRef, FetchStrategy, GetRecordOptions, GetRecordResult, GetRecordsOptions, LazyFetch, LinkDeclaration, SerializedFunction, SyncFetch, WorkflowMeta, } from './doctype';
 export { parseDoctype, parseField, validateDoctype, validateField, type ValidationError, type ValidationResult, } from './validation';
 export { buildScalarMap, classifyFieldType, convertGraphQLSchema, defaultIsEntityField, defaultIsEntityType, GQL_SCALAR_MAP, INTERNAL_SCALARS, WELL_KNOWN_SCALARS, type ConvertedGraphQLDoctype, type GraphQLConversionFieldMeta, type GraphQLConversionOptions, type IntrospectionSource, } from './converter';

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,QAAQ,EACR,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GAClB,MAAM,aAAa,CAAA;AAGpB,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGvE,YAAY,EACX,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,UAAU,EACV,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,YAAY,GACZ,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACrB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,GACxB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGtH,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAG7C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC,OAAO,EACN,kBAAkB,EAClB,mBAAmB,EACnB,QAAQ,EACR,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GAClB,MAAM,aAAa,CAAA;AAGpB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACjH,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAGrG,YAAY,EACX,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,UAAU,EACV,cAAc,EACd,WAAW,EACX,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,YAAY,GACZ,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACrB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,GACxB,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGtH,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/src/index.js

@@ -1,5 +1,8 @@
+// Table authoring types
+export { TableViewConfig } from './table';
 // Field types
 export { StonecropFieldType, BUILTIN_FIELD_TYPES, TYPE_MAP, getDefaultComponent, resolveComponent, isBuiltinFieldType, } from './fieldtype';
+export { DoctypeFieldSchema, FieldsetFieldSchema, TableFieldSchema, ValueFieldSchema } from './field';
 // Validation helpers
 export { parseDoctype, parseField, validateDoctype, validateField, } from './validation';
 // GraphQL to Doctype conversion

package/dist/src/validation.d.ts

@@ -1,4 +1,3 @@
-import { FieldMeta } from './field';
 import { DoctypeMeta } from './doctype';
 /**
  * Validation error with path information
@@ -21,7 +20,7 @@ export interface ValidationResult {
     errors: ValidationError[];
 }
 /**
- * Validate a field definition
+ * Validate a field definition against the DoctypeField discriminated union
  * @param data - Data to validate
  * @returns Validation result
  * @public
@@ -37,11 +36,11 @@ export declare function validateDoctype(data: unknown): ValidationResult;
 /**
  * Parse and validate a field, throwing on failure
  * @param data - Data to parse
- * @returns Validated FieldMeta
+ * @returns Validated DoctypeField
  * @throws ZodError if validation fails
  * @public
  */
-export declare function parseField(data: unknown): FieldMeta;
+export declare function parseField(data: unknown): import('./field').DoctypeField;
 /**
  * Parse and validate a doctype, throwing on failure
  * @param data - Data to parse
@@ -50,6 +49,6 @@ export declare function parseField(data: unknown): FieldMeta;
  * @public
  */
 export declare function parseDoctype(data: unknown): DoctypeMeta;
-export type { FieldMeta } from './field';
+export type { DoctypeField, ValueField, FieldsetField, TableField } from './field';
 export type { DoctypeMeta } from './doctype';
 //# sourceMappingURL=validation.d.ts.map

package/dist/src/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,mCAAmC;IACnC,IAAI,EAAE,WAAW,EAAE,CAAA;IAEnB,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAEhB,mDAAmD;IACnD,MAAM,EAAE,eAAe,EAAE,CAAA;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAc7D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAc/D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CAEvD;AAGD,YAAY,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AACxC,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/validation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,mCAAmC;IACnC,IAAI,EAAE,WAAW,EAAE,CAAA;IAEnB,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAEhB,mDAAmD;IACnD,MAAM,EAAE,eAAe,EAAE,CAAA;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAc7D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAc/D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,SAAS,EAAE,YAAY,CAExE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,CAEvD;AAGD,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAClF,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}

package/dist/src/validation.js

@@ -1,13 +1,13 @@
-import { FieldMeta } from './field';
+import { DoctypeFieldSchema } from './field';
 import { DoctypeMeta } from './doctype';
 /**
- * Validate a field definition
+ * Validate a field definition against the DoctypeField discriminated union
  * @param data - Data to validate
  * @returns Validation result
  * @public
  */
 export function validateField(data) {
-    const result = FieldMeta.safeParse(data);
+    const result = DoctypeFieldSchema.safeParse(data);
     if (result.success) {
         return { success: true, errors: [] };
     }
@@ -41,12 +41,12 @@ export function validateDoctype(data) {
 /**
  * Parse and validate a field, throwing on failure
  * @param data - Data to parse
- * @returns Validated FieldMeta
+ * @returns Validated DoctypeField
  * @throws ZodError if validation fails
  * @public
  */
 export function parseField(data) {
-    return FieldMeta.parse(data);
+    return DoctypeFieldSchema.parse(data);
 }
 /**
  * Parse and validate a doctype, throwing on failure

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/schema",
-  "version": "0.13.7",
+  "version": "0.13.9",
   "type": "module",
   "types": "./dist/schema.d.ts",
   "exports": {