@stonecrop/schema 0.10.2 → 0.10.4

package/dist/src/doctype.d.ts

@@ -4,33 +4,13 @@ import { z } from 'zod';
  * @public
  */
 export declare const ActionDefinition: z.ZodObject<{
-    /** Display label for the action */
     label: z.ZodString;
-    /** Handler function name or path */
     handler: z.ZodString;
-    /** Fields that must have values before action can execute */
-    requiredFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Workflow states where this action is available */
-    allowedStates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Whether to show a confirmation dialog */
+    requiredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowedStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
     confirm: z.ZodOptional<z.ZodBoolean>;
-    /** Additional arguments for the action */
     args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    label: string;
-    handler: string;
-    requiredFields?: string[] | undefined;
-    allowedStates?: string[] | undefined;
-    confirm?: boolean | undefined;
-    args?: Record<string, unknown> | undefined;
-}, {
-    label: string;
-    handler: string;
-    requiredFields?: string[] | undefined;
-    allowedStates?: string[] | undefined;
-    confirm?: boolean | undefined;
-    args?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Action definition type inferred from Zod schema
  * @public
@@ -41,58 +21,16 @@ export type ActionDefinition = z.infer<typeof ActionDefinition>;
  * @public
  */
 export declare const WorkflowMeta: z.ZodObject<{
-    /** List of workflow states */
-    states: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Actions available in this workflow */
+    states: z.ZodOptional<z.ZodArray<z.ZodString>>;
     actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        /** Display label for the action */
         label: z.ZodString;
-        /** Handler function name or path */
         handler: z.ZodString;
-        /** Fields that must have values before action can execute */
-        requiredFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Workflow states where this action is available */
-        allowedStates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Whether to show a confirmation dialog */
+        requiredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowedStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
         confirm: z.ZodOptional<z.ZodBoolean>;
-        /** Additional arguments for the action */
         args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, "strip", z.ZodTypeAny, {
-        label: string;
-        handler: string;
-        requiredFields?: string[] | undefined;
-        allowedStates?: string[] | undefined;
-        confirm?: boolean | undefined;
-        args?: Record<string, unknown> | undefined;
-    }, {
-        label: string;
-        handler: string;
-        requiredFields?: string[] | undefined;
-        allowedStates?: string[] | undefined;
-        confirm?: boolean | undefined;
-        args?: Record<string, unknown> | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    states?: string[] | undefined;
-    actions?: Record<string, {
-        label: string;
-        handler: string;
-        requiredFields?: string[] | undefined;
-        allowedStates?: string[] | undefined;
-        confirm?: boolean | undefined;
-        args?: Record<string, unknown> | undefined;
-    }> | undefined;
-}, {
-    states?: string[] | undefined;
-    actions?: Record<string, {
-        label: string;
-        handler: string;
-        requiredFields?: string[] | undefined;
-        allowedStates?: string[] | undefined;
-        confirm?: boolean | undefined;
-        args?: Record<string, unknown> | undefined;
-    }> | undefined;
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 /**
  * Workflow metadata type inferred from Zod schema
  * @public
@@ -103,218 +41,80 @@ export type WorkflowMeta = z.infer<typeof WorkflowMeta>;
  * @public
  */
 export declare const DoctypeMeta: z.ZodObject<{
-    /** Display name of the doctype */
     name: z.ZodString;
-    /** URL-friendly slug (kebab-case) */
     slug: z.ZodOptional<z.ZodString>;
-    /** Database table name */
     tableName: z.ZodOptional<z.ZodString>;
-    /** Field definitions */
     fields: z.ZodArray<z.ZodObject<{
         fieldname: z.ZodString;
-        fieldtype: z.ZodEnum<["Data", "Text", "Int", "Float", "Decimal", "Check", "Date", "Time", "Datetime", "Duration", "DateRange", "JSON", "Code", "Link", "Doctype", "Attach", "Currency", "Quantity", "Select"]>;
+        fieldtype: z.ZodEnum<{
+            Data: "Data";
+            Text: "Text";
+            Int: "Int";
+            Float: "Float";
+            Decimal: "Decimal";
+            Check: "Check";
+            Date: "Date";
+            Time: "Time";
+            Datetime: "Datetime";
+            Duration: "Duration";
+            DateRange: "DateRange";
+            JSON: "JSON";
+            Code: "Code";
+            Link: "Link";
+            Doctype: "Doctype";
+            Attach: "Attach";
+            Currency: "Currency";
+            Quantity: "Quantity";
+            Select: "Select";
+        }>;
         component: z.ZodOptional<z.ZodString>;
         label: z.ZodOptional<z.ZodString>;
         width: z.ZodOptional<z.ZodString>;
-        align: z.ZodOptional<z.ZodEnum<["left", "center", "right", "start", "end"]>>;
+        align: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            center: "center";
+            right: "right";
+            start: "start";
+            end: "end";
+        }>>;
         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<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
         mask: z.ZodOptional<z.ZodString>;
         validation: z.ZodOptional<z.ZodObject<{
             errorMessage: z.ZodString;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            errorMessage: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            errorMessage: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">>>;
-    }, "strip", z.ZodTypeAny, {
-        fieldname: string;
-        fieldtype: "Data" | "Text" | "Int" | "Float" | "Decimal" | "Check" | "Date" | "Time" | "Datetime" | "Duration" | "DateRange" | "JSON" | "Code" | "Link" | "Doctype" | "Attach" | "Currency" | "Quantity" | "Select";
-        value?: unknown;
-        options?: string | string[] | Record<string, unknown> | undefined;
-        validation?: z.objectOutputType<{
-            errorMessage: z.ZodString;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-        component?: string | undefined;
-        label?: string | undefined;
-        width?: string | undefined;
-        align?: "left" | "center" | "right" | "start" | "end" | undefined;
-        required?: boolean | undefined;
-        readOnly?: boolean | undefined;
-        edit?: boolean | undefined;
-        hidden?: boolean | undefined;
-        default?: unknown;
-        mask?: string | undefined;
-    }, {
-        fieldname: string;
-        fieldtype: "Data" | "Text" | "Int" | "Float" | "Decimal" | "Check" | "Date" | "Time" | "Datetime" | "Duration" | "DateRange" | "JSON" | "Code" | "Link" | "Doctype" | "Attach" | "Currency" | "Quantity" | "Select";
-        value?: unknown;
-        options?: string | string[] | Record<string, unknown> | undefined;
-        validation?: z.objectInputType<{
-            errorMessage: z.ZodString;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-        component?: string | undefined;
-        label?: string | undefined;
-        width?: string | undefined;
-        align?: "left" | "center" | "right" | "start" | "end" | undefined;
-        required?: boolean | undefined;
-        readOnly?: boolean | undefined;
-        edit?: boolean | undefined;
-        hidden?: boolean | undefined;
-        default?: unknown;
-        mask?: string | undefined;
-    }>, "many">;
-    /** Workflow configuration */
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
     workflow: z.ZodOptional<z.ZodObject<{
-        /** List of workflow states */
-        states: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        /** Actions available in this workflow */
+        states: z.ZodOptional<z.ZodArray<z.ZodString>>;
         actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            /** Display label for the action */
             label: z.ZodString;
-            /** Handler function name or path */
             handler: z.ZodString;
-            /** Fields that must have values before action can execute */
-            requiredFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /** Workflow states where this action is available */
-            allowedStates: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            /** Whether to show a confirmation dialog */
+            requiredFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowedStates: z.ZodOptional<z.ZodArray<z.ZodString>>;
             confirm: z.ZodOptional<z.ZodBoolean>;
-            /** Additional arguments for the action */
             args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, "strip", z.ZodTypeAny, {
-            label: string;
-            handler: string;
-            requiredFields?: string[] | undefined;
-            allowedStates?: string[] | undefined;
-            confirm?: boolean | undefined;
-            args?: Record<string, unknown> | undefined;
-        }, {
-            label: string;
-            handler: string;
-            requiredFields?: string[] | undefined;
-            allowedStates?: string[] | undefined;
-            confirm?: boolean | undefined;
-            args?: Record<string, unknown> | undefined;
-        }>>>;
-    }, "strip", z.ZodTypeAny, {
-        states?: string[] | undefined;
-        actions?: Record<string, {
-            label: string;
-            handler: string;
-            requiredFields?: string[] | undefined;
-            allowedStates?: string[] | undefined;
-            confirm?: boolean | undefined;
-            args?: Record<string, unknown> | undefined;
-        }> | undefined;
-    }, {
-        states?: string[] | undefined;
-        actions?: Record<string, {
-            label: string;
-            handler: string;
-            requiredFields?: string[] | undefined;
-            allowedStates?: string[] | undefined;
-            confirm?: boolean | undefined;
-            args?: Record<string, unknown> | undefined;
-        }> | undefined;
-    }>>;
-    /** Parent doctype for inheritance */
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
     inherits: z.ZodOptional<z.ZodString>;
-    /** Doctype to use for list views */
     listDoctype: z.ZodOptional<z.ZodString>;
-    /** Parent doctype for child tables */
     parentDoctype: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    fields: {
-        fieldname: string;
-        fieldtype: "Data" | "Text" | "Int" | "Float" | "Decimal" | "Check" | "Date" | "Time" | "Datetime" | "Duration" | "DateRange" | "JSON" | "Code" | "Link" | "Doctype" | "Attach" | "Currency" | "Quantity" | "Select";
-        value?: unknown;
-        options?: string | string[] | Record<string, unknown> | undefined;
-        validation?: z.objectOutputType<{
-            errorMessage: z.ZodString;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-        component?: string | undefined;
-        label?: string | undefined;
-        width?: string | undefined;
-        align?: "left" | "center" | "right" | "start" | "end" | undefined;
-        required?: boolean | undefined;
-        readOnly?: boolean | undefined;
-        edit?: boolean | undefined;
-        hidden?: boolean | undefined;
-        default?: unknown;
-        mask?: string | undefined;
-    }[];
-    slug?: string | undefined;
-    tableName?: string | undefined;
-    workflow?: {
-        states?: string[] | undefined;
-        actions?: Record<string, {
-            label: string;
-            handler: string;
-            requiredFields?: string[] | undefined;
-            allowedStates?: string[] | undefined;
-            confirm?: boolean | undefined;
-            args?: Record<string, unknown> | undefined;
-        }> | undefined;
-    } | undefined;
-    inherits?: string | undefined;
-    listDoctype?: string | undefined;
-    parentDoctype?: string | undefined;
-}, {
-    name: string;
-    fields: {
-        fieldname: string;
-        fieldtype: "Data" | "Text" | "Int" | "Float" | "Decimal" | "Check" | "Date" | "Time" | "Datetime" | "Duration" | "DateRange" | "JSON" | "Code" | "Link" | "Doctype" | "Attach" | "Currency" | "Quantity" | "Select";
-        value?: unknown;
-        options?: string | string[] | Record<string, unknown> | undefined;
-        validation?: z.objectInputType<{
-            errorMessage: z.ZodString;
-        }, z.ZodTypeAny, "passthrough"> | undefined;
-        component?: string | undefined;
-        label?: string | undefined;
-        width?: string | undefined;
-        align?: "left" | "center" | "right" | "start" | "end" | undefined;
-        required?: boolean | undefined;
-        readOnly?: boolean | undefined;
-        edit?: boolean | undefined;
-        hidden?: boolean | undefined;
-        default?: unknown;
-        mask?: string | undefined;
-    }[];
-    slug?: string | undefined;
-    tableName?: string | undefined;
-    workflow?: {
-        states?: string[] | undefined;
-        actions?: Record<string, {
-            label: string;
-            handler: string;
-            requiredFields?: string[] | undefined;
-            allowedStates?: string[] | undefined;
-            confirm?: boolean | undefined;
-            args?: Record<string, unknown> | undefined;
-        }> | undefined;
-    } | undefined;
-    inherits?: string | undefined;
-    listDoctype?: string | undefined;
-    parentDoctype?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Doctype metadata type inferred from Zod schema
  * @public
  */
 export type DoctypeMeta = z.infer<typeof DoctypeMeta>;
 /**
- * Route context for identifying what doctype/record we're working with.
+ * Context for identifying what doctype/record we're working with.
  * Used by graphql-middleware and graphql-client to resolve schema metadata.
  * @public
  */
-export interface RouteContext {
+export interface DoctypeContext {
     /** Doctype name (e.g., 'Task', 'Customer') */
     doctype: string;
     /** Optional record ID for viewing/editing a specific record */
@@ -322,4 +122,65 @@ export interface RouteContext {
     /** Additional context properties */
     [key: string]: unknown;
 }
+/**
+ * Base interface for doctype metadata passed to DataClient methods.
+ * Only requires properties needed for record fetching.
+ * @public
+ */
+export interface DoctypeRef {
+    /** Doctype name (e.g., 'Task', 'Customer') */
+    name: string;
+    /** URL-friendly slug (e.g., 'task', 'customer') */
+    slug?: string;
+}
+/**
+ * Interface for data clients that fetch doctype metadata and records.
+ * Implemented by \@stonecrop/graphql-client's StonecropClient.
+ * Custom implementations can use any backend (REST, local storage, etc.).
+ *
+ * @typeParam T - Doctype reference type for record operations (defaults to DoctypeRef)
+ * @typeParam M - Doctype metadata return type for getMeta (defaults to DoctypeMeta)
+ * @public
+ */
+export interface DataClient<T extends DoctypeRef = DoctypeRef, M = DoctypeMeta> {
+    /**
+     * Fetch doctype metadata
+     * @param context - Doctype context identifying the doctype
+     * @returns Doctype metadata or null if not found
+     */
+    getMeta(context: DoctypeContext): Promise<M | null>;
+    /**
+     * Fetch a single record by ID
+     * @param doctype - Doctype reference (name and optional slug)
+     * @param recordId - Record ID to fetch
+     * @returns Record data or null if not found
+     */
+    getRecord(doctype: T, recordId: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Fetch multiple records
+     * @param doctype - Doctype reference (name and optional slug)
+     * @param options - Optional filters, pagination, sorting
+     * @returns Array of record data
+     */
+    getRecords(doctype: T, options?: {
+        filters?: Record<string, unknown>;
+        orderBy?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Execute a doctype action (e.g., SUBMIT, APPROVE, save).
+     * All state changes flow through this single mutation endpoint.
+     *
+     * @param doctype - Doctype reference (name and optional slug)
+     * @param action - Action name to execute (e.g., 'SUBMIT', 'APPROVE', 'save')
+     * @param args - Action arguments (typically record ID and/or form data)
+     * @returns Action result with success status, response data, and any error
+     */
+    runAction(doctype: T, action: string, args?: unknown[]): Promise<{
+        success: boolean;
+        data: unknown;
+        error: string | null;
+    }>;
+}
 //# sourceMappingURL=doctype.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"doctype.d.ts","sourceRoot":"","sources":["../../src/doctype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC5B,mCAAmC;;IAGnC,oCAAoC;;IAGpC,6DAA6D;;IAG7D,qDAAqD;;IAGrD,4CAA4C;;IAG5C,0CAA0C;;;;;;;;;;;;;;;;EAEzC,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D;;;GAGG;AACH,eAAO,MAAM,YAAY;IACxB,8BAA8B;;IAG9B,yCAAyC;;QAjCzC,mCAAmC;;QAGnC,oCAAoC;;QAGpC,6DAA6D;;QAG7D,qDAAqD;;QAGrD,4CAA4C;;QAG5C,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBzC,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,WAAW;IACvB,kCAAkC;;IAGlC,qCAAqC;;IAGrC,0BAA0B;;IAG1B,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGxB,6BAA6B;;QA9B7B,8BAA8B;;QAG9B,yCAAyC;;YAjCzC,mCAAmC;;YAGnC,oCAAoC;;YAGpC,6DAA6D;;YAG7D,qDAAqD;;YAGrD,4CAA4C;;YAG5C,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgD1C,qCAAqC;;IAGrC,oCAAoC;;IAGpC,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErC,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oCAAoC;IACpC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACtB"}
+{"version":3,"file":"doctype.d.ts","sourceRoot":"","sources":["../../src/doctype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;iBAuB1B,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;iBAWtB,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BrB,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oCAAoC;IACpC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAA;IACZ,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,EAAE,CAAC,GAAG,WAAW;IAC7E;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;IAEnD;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;IAEhF;;;;;OAKG;IACH,UAAU,CACT,OAAO,EAAE,CAAC,EACV,OAAO,CAAC,EAAE;QACT,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjC,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;KACf,GACC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAA;IAErC;;;;;;;;OAQG;IACH,SAAS,CACR,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,EAAE,GACd,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAA;CACrE"}

package/dist/src/field.d.ts

@@ -10,7 +10,7 @@ import { z } from 'zod';
  *
  * @public
  */
-export declare const FieldOptions: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+export declare const FieldOptions: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
 /**
  * Field options type inferred from Zod schema
  * @public
@@ -23,13 +23,7 @@ export type FieldOptions = z.infer<typeof FieldOptions>;
 export declare const FieldValidation: z.ZodObject<{
     /** Error message to display when validation fails */
     errorMessage: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    /** Error message to display when validation fails */
-    errorMessage: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    /** Error message to display when validation fails */
-    errorMessage: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
+}, z.core.$loose>;
 /**
  * Field validation type inferred from Zod schema
  * @public
@@ -44,98 +38,51 @@ export type FieldValidation = z.infer<typeof FieldValidation>;
  * @public
  */
 export declare const FieldMeta: z.ZodObject<{
-    /** Unique identifier for the field within its doctype */
     fieldname: z.ZodString;
-    /** Semantic field type - determines behavior and default component */
-    fieldtype: z.ZodEnum<["Data", "Text", "Int", "Float", "Decimal", "Check", "Date", "Time", "Datetime", "Duration", "DateRange", "JSON", "Code", "Link", "Doctype", "Attach", "Currency", "Quantity", "Select"]>;
-    /** Vue component to render this field. If not specified, derived from TYPE_MAP */
+    fieldtype: z.ZodEnum<{
+        Data: "Data";
+        Text: "Text";
+        Int: "Int";
+        Float: "Float";
+        Decimal: "Decimal";
+        Check: "Check";
+        Date: "Date";
+        Time: "Time";
+        Datetime: "Datetime";
+        Duration: "Duration";
+        DateRange: "DateRange";
+        JSON: "JSON";
+        Code: "Code";
+        Link: "Link";
+        Doctype: "Doctype";
+        Attach: "Attach";
+        Currency: "Currency";
+        Quantity: "Quantity";
+        Select: "Select";
+    }>;
     component: z.ZodOptional<z.ZodString>;
-    /** Human-readable label for the field */
     label: z.ZodOptional<z.ZodString>;
-    /** Width of the field (CSS value, e.g., "40ch", "200px") */
     width: z.ZodOptional<z.ZodString>;
-    /** Text alignment within the field */
-    align: z.ZodOptional<z.ZodEnum<["left", "center", "right", "start", "end"]>>;
-    /** Whether the field is required */
+    align: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        center: "center";
+        right: "right";
+        start: "start";
+        end: "end";
+    }>>;
     required: z.ZodOptional<z.ZodBoolean>;
-    /** Whether the field is read-only */
     readOnly: z.ZodOptional<z.ZodBoolean>;
-    /** Whether the field is editable (for table cells) */
     edit: z.ZodOptional<z.ZodBoolean>;
-    /** Whether the field is hidden from the UI */
     hidden: z.ZodOptional<z.ZodBoolean>;
-    /** Current value of the field */
     value: z.ZodOptional<z.ZodUnknown>;
-    /** Default value for new records */
     default: z.ZodOptional<z.ZodUnknown>;
-    /**
-     * 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: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    /**
-     * 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' ? '(###) ###-####' : '####-######'"`
-     */
+    options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
     mask: z.ZodOptional<z.ZodString>;
-    /** Validation configuration */
     validation: z.ZodOptional<z.ZodObject<{
         /** Error message to display when validation fails */
         errorMessage: z.ZodString;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        /** Error message to display when validation fails */
-        errorMessage: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        /** Error message to display when validation fails */
-        errorMessage: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">>>;
-}, "strip", z.ZodTypeAny, {
-    fieldname: string;
-    fieldtype: "Data" | "Text" | "Int" | "Float" | "Decimal" | "Check" | "Date" | "Time" | "Datetime" | "Duration" | "DateRange" | "JSON" | "Code" | "Link" | "Doctype" | "Attach" | "Currency" | "Quantity" | "Select";
-    value?: unknown;
-    options?: string | string[] | Record<string, unknown> | undefined;
-    validation?: z.objectOutputType<{
-        /** Error message to display when validation fails */
-        errorMessage: z.ZodString;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
-    component?: string | undefined;
-    label?: string | undefined;
-    width?: string | undefined;
-    align?: "left" | "center" | "right" | "start" | "end" | undefined;
-    required?: boolean | undefined;
-    readOnly?: boolean | undefined;
-    edit?: boolean | undefined;
-    hidden?: boolean | undefined;
-    default?: unknown;
-    mask?: string | undefined;
-}, {
-    fieldname: string;
-    fieldtype: "Data" | "Text" | "Int" | "Float" | "Decimal" | "Check" | "Date" | "Time" | "Datetime" | "Duration" | "DateRange" | "JSON" | "Code" | "Link" | "Doctype" | "Attach" | "Currency" | "Quantity" | "Select";
-    value?: unknown;
-    options?: string | string[] | Record<string, unknown> | undefined;
-    validation?: z.objectInputType<{
-        /** Error message to display when validation fails */
-        errorMessage: z.ZodString;
-    }, z.ZodTypeAny, "passthrough"> | undefined;
-    component?: string | undefined;
-    label?: string | undefined;
-    width?: string | undefined;
-    align?: "left" | "center" | "right" | "start" | "end" | undefined;
-    required?: boolean | undefined;
-    readOnly?: boolean | undefined;
-    edit?: boolean | undefined;
-    hidden?: boolean | undefined;
-    default?: unknown;
-    mask?: string | undefined;
-}>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
 /**
  * Field metadata type inferred from Zod schema
  * @public

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,oGAIvB,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,eAAe;IAE1B,qDAAqD;;;IAArD,qDAAqD;;;IAArD,qDAAqD;;gCAGxC,CAAA;AAEf;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS;IAGrB,yDAAyD;;IAGzD,sEAAsE;;IAKtE,kFAAkF;;IAKlF,yCAAyC;;IAGzC,4DAA4D;;IAG5D,sCAAsC;;IAKtC,oCAAoC;;IAGpC,qCAAqC;;IAGrC,sDAAsD;;IAGtD,8CAA8C;;IAK9C,iCAAiC;;IAGjC,oCAAoC;;IAKpC;;;;;;;OAOG;;IAGH;;;;;;;OAOG;;IAKH,+BAA+B;;QA1F9B,qDAAqD;;;QAArD,qDAAqD;;;QAArD,qDAAqD;;;;;;;;;QAArD,qDAAqD;;;;;;;;;;;;;;;;;;;QAArD,qDAAqD;;;;;;;;;;;;;EA4FrD,CAAA;AAEF;;;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;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;;;iBAqGpD,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/src/fieldtype.d.ts

@@ -4,7 +4,27 @@ import { z } from 'zod';
  * These are consistent across forms and tables.
  * @public
  */
-export declare const StonecropFieldType: z.ZodEnum<["Data", "Text", "Int", "Float", "Decimal", "Check", "Date", "Time", "Datetime", "Duration", "DateRange", "JSON", "Code", "Link", "Doctype", "Attach", "Currency", "Quantity", "Select"]>;
+export declare const StonecropFieldType: z.ZodEnum<{
+    Data: "Data";
+    Text: "Text";
+    Int: "Int";
+    Float: "Float";
+    Decimal: "Decimal";
+    Check: "Check";
+    Date: "Date";
+    Time: "Time";
+    Datetime: "Datetime";
+    Duration: "Duration";
+    DateRange: "DateRange";
+    JSON: "JSON";
+    Code: "Code";
+    Link: "Link";
+    Doctype: "Doctype";
+    Attach: "Attach";
+    Currency: "Currency";
+    Quantity: "Quantity";
+    Select: "Select";
+}>;
 /**
  * Stonecrop field type enum inferred from Zod schema
  * @public

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

@@ -1 +1 @@
-{"version":3,"file":"fieldtype.d.ts","sourceRoot":"","sources":["../../src/fieldtype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,qMAoB7B,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,SAAS,EAAE,kBAAkB,CAAA;CAC7B;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,kBAAkB,EAAE,aAAa,CAmC9D,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,kBAAkB,GAAG,MAAM,CAEzE"}
+{"version":3,"file":"fieldtype.d.ts","sourceRoot":"","sources":["../../src/fieldtype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;EAyB5B,CAAA;AAEH;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,SAAS,EAAE,kBAAkB,CAAA;CAC7B;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,kBAAkB,EAAE,aAAa,CAmC9D,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,kBAAkB,GAAG,MAAM,CAEzE"}

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 export { StonecropFieldType, TYPE_MAP, getDefaultComponent } from './fieldtype';
 export { FieldMeta, FieldOptions, FieldValidation } from './field';
-export { DoctypeMeta, WorkflowMeta, ActionDefinition, type RouteContext } from './doctype';
+export { DoctypeMeta, WorkflowMeta, ActionDefinition, type DoctypeContext, type DoctypeRef, type DataClient, } from './doctype';
 export { validateField, validateDoctype, parseField, parseDoctype, type ValidationResult, type ValidationError, } from './validation';
 export { convertGraphQLSchema, GQL_SCALAR_MAP, WELL_KNOWN_SCALARS, INTERNAL_SCALARS, buildScalarMap, defaultIsEntityType, defaultIsEntityField, classifyFieldType, type IntrospectionSource, type GraphQLConversionOptions, type GraphQLConversionFieldMeta, type ConvertedGraphQLDoctype, } from './converter';
 export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from './naming';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAG/E,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGlE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AAG1F,OAAO,EACN,aAAa,EACb,eAAe,EACf,UAAU,EACV,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACpB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,GAC5B,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,kBAAkB,IAAI,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAChF,YAAY,EAAE,SAAS,IAAI,aAAa,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC3F,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,YAAY,EAAE,WAAW,IAAI,eAAe,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAG/E,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGlE,OAAO,EACN,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,UAAU,GACf,MAAM,WAAW,CAAA;AAGlB,OAAO,EACN,aAAa,EACb,eAAe,EACf,UAAU,EACV,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACpB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,GAC5B,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,kBAAkB,IAAI,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAChF,YAAY,EAAE,SAAS,IAAI,aAAa,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC3F,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,YAAY,EAAE,WAAW,IAAI,eAAe,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,WAAW,CAAA"}

package/dist/src/validation.d.ts

@@ -6,7 +6,7 @@ import { DoctypeMeta } from './doctype';
  */
 export interface ValidationError {
     /** Path to the invalid property */
-    path: (string | number)[];
+    path: PropertyKey[];
     /** Error message */
     message: string;
 }