@stonecrop/schema 0.7.0

package/dist/index.d.ts

@@ -0,0 +1,781 @@
+import { z } from 'zod';
+
+/**
+ * Action definition within a workflow
+ * @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 */
+    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;
+}>;
+
+export declare type ActionDefinition = z.infer<typeof ActionDefinition>;
+
+/**
+ * Converts camelCase to Title Case label
+ * @param camelCase - Camel case string
+ * @returns Title case label
+ * @public
+ * @example
+ * ```typescript
+ * camelToLabel('userEmail') // 'User Email'
+ * camelToLabel('firstName') // 'First Name'
+ * ```
+ */
+export declare function camelToLabel(camelCase: string): string;
+
+/**
+ * Converts camelCase to snake_case
+ * @param camelCase - Camel case string
+ * @returns Snake case string
+ * @public
+ * @example
+ * ```typescript
+ * camelToSnake('userEmail') // 'user_email'
+ * camelToSnake('createdAt') // 'created_at'
+ * ```
+ */
+export declare function camelToSnake(camelCase: string): string;
+
+/**
+ * Extended field with conversion metadata (only used during schema-tools output)
+ * @public
+ */
+export declare interface ConversionFieldMeta extends FieldMeta {
+    _pgType?: string;
+    _unmapped?: boolean;
+}
+
+/**
+ * Options for DDL to doctype conversion
+ * @public
+ */
+export declare interface ConversionOptions {
+    /** Schema to filter tables by */
+    schema?: string;
+    /** Tables to exclude */
+    exclude?: string[];
+    /** Override type mappings */
+    typeOverrides?: Record<string, Partial<FieldMeta>>;
+    /** How to handle inherited fields */
+    inheritanceMode: 'flatten' | 'reference';
+    /** Include unmapped type metadata in output */
+    includeUnmappedMeta?: boolean;
+    /** Use camelCase for field names (default: false, keeps snake_case) */
+    useCamelCase?: boolean;
+}
+
+/**
+ * Output of schema conversion - uses DoctypeMeta but with optional conversion metadata
+ * @public
+ */
+export declare interface ConvertedDoctype extends Omit<DoctypeMeta, 'fields'> {
+    fields: ConversionFieldMeta[];
+}
+
+/**
+ * Convert PostgreSQL DDL to Stonecrop doctype schemas
+ * @public
+ */
+export declare function convertSchema(sql: string, options?: ConversionOptions): ConvertedDoctype[];
+
+/**
+ * Converts SQL column name to Stonecrop field naming convention
+ * Handles special cases like ID suffixes
+ * @param sqlName - SQL column name (snake_case)
+ * @returns Field name and label
+ * @public
+ * @example
+ * ```typescript
+ * convertSQLName('user_email')
+ * // { fieldname: 'userEmail', label: 'User Email', originalName: 'user_email' }
+ *
+ * convertSQLName('user_id')
+ * // { fieldname: 'userId', label: 'User', originalName: 'user_id' }
+ * ```
+ */
+export declare function convertSQLName(sqlName: string): NameConversion;
+
+/**
+ * Batch converts multiple SQL column names
+ * @param sqlNames - Array of SQL column names
+ * @returns Array of name conversions
+ * @public
+ */
+export declare function convertSQLNames(sqlNames: string[]): NameConversion[];
+
+/**
+ * Creates a bidirectional mapping between SQL and Stonecrop names
+ * @param sqlNames - Array of SQL column names
+ * @returns Mapping object with both directions
+ * @public
+ */
+export declare function createNameMapping(sqlNames: string[]): {
+    sqlToFieldname: Map<string, string>;
+    fieldnameToSQL: Map<string, string>;
+    conversions: NameConversion[];
+};
+
+/**
+ * Doctype metadata - complete definition of a doctype
+ * @public
+ */
+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"]>;
+        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"]>>;
+        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>]>>;
+        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 */
+    workflow: z.ZodOptional<z.ZodObject<{
+        /** List of workflow states */
+        states: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Actions available in this workflow */
+        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 */
+            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 */
+    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;
+}>;
+
+declare type DoctypeMeta = z.infer<typeof DoctypeMeta>;
+export { DoctypeMeta }
+export { DoctypeMeta as DoctypeMetaType }
+
+/**
+ * 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.
+ *
+ * @public
+ */
+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 */
+    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 */
+    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 (e.g., "##/##/####" for dates) */
+    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;
+}>;
+
+declare type FieldMeta = z.infer<typeof FieldMeta>;
+export { FieldMeta }
+export { FieldMeta as FieldMetaType }
+
+/**
+ * Field options - flexible bag for type-specific configuration.
+ *
+ * Usage by fieldtype:
+ * - Link/Doctype: target doctype slug as string ("customer", "sales-order-item")
+ * - Select: array of choices (["Draft", "Submitted", "Cancelled"])
+ * - Decimal: config object ({ precision: 10, scale: 2 })
+ * - Code: config object ({ language: "python" })
+ *
+ * @public
+ */
+declare const FieldOptions: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+
+declare type FieldOptions = z.infer<typeof FieldOptions>;
+export { FieldOptions }
+export { FieldOptions as FieldOptionsType }
+
+/* Excluded from this release type: FieldTemplate */
+
+declare interface FieldTemplate_2 {
+    component: string;
+    fieldtype: StonecropFieldType;
+    _unmapped?: boolean;
+}
+
+/**
+ * Validation configuration for form fields
+ * @public
+ */
+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">>;
+
+export declare type FieldValidation = z.infer<typeof FieldValidation>;
+
+/**
+ * Get the default component for a field type
+ * @param fieldtype - The semantic field type
+ * @returns The default component name
+ * @public
+ */
+export declare function getDefaultComponent(fieldtype: StonecropFieldType): string;
+
+/**
+ * Options for column to field mapping
+ * @public
+ */
+export declare interface MapColumnOptions {
+    /** Include unmapped type metadata in output */
+    includeUnmappedMeta?: boolean;
+    /** Use camelCase for field names (default: false, keeps snake_case) */
+    useCamelCase?: boolean;
+}
+
+/**
+ * Map a parsed column to a Stonecrop field definition
+ * @public
+ */
+export declare function mapColumnToField(column: ParsedColumn, _tableRegistry: Map<string, ParsedTable>, options?: MapColumnOptions): ConversionFieldMeta;
+
+/**
+ * Result of name conversion
+ * @public
+ */
+export declare interface NameConversion {
+    /** Converted fieldname (camelCase) */
+    fieldname: string;
+    /** Human-readable label */
+    label: string;
+    /** Original SQL name */
+    originalName: string;
+}
+
+/**
+ * Normalize raw PostgreSQL type string to canonical PostgresType
+ * @public
+ */
+export declare function normalizeType(rawType: string): PostgresType;
+
+/**
+ * Intermediate representation of a parsed column (from DDL)
+ * @public
+ */
+export declare interface ParsedColumn {
+    name: string;
+    dataType: string;
+    normalizedType: PostgresType;
+    nullable: boolean;
+    isGenerated: boolean;
+    defaultValue?: string;
+    arrayDimensions: number;
+    reference?: {
+        schema?: string;
+        table: string;
+        column: string;
+        onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    };
+    precision?: number;
+    scale?: number;
+    length?: number;
+}
+
+/**
+ * Parse PostgreSQL DDL and extract table definitions
+ * @public
+ */
+export declare function parseDDL(sql: string): ParsedTable[];
+
+/**
+ * Parse and validate a doctype, throwing on failure
+ * @param data - Data to parse
+ * @returns Validated DoctypeMeta
+ * @throws ZodError if validation fails
+ * @public
+ */
+export declare function parseDoctype(data: unknown): DoctypeMeta;
+
+/**
+ * Intermediate representation of a parsed table (from DDL)
+ * @public
+ */
+export declare interface ParsedTable {
+    name: string;
+    schema?: string;
+    columns: ParsedColumn[];
+    inherits?: string[];
+    /** Table comment from COMMENT ON TABLE statement */
+    comment?: string;
+    /** Doctype name extracted from comment (if using @doctype convention) */
+    doctypeName?: string;
+}
+
+/**
+ * Parse and validate a field, throwing on failure
+ * @param data - Data to parse
+ * @returns Validated FieldMeta
+ * @throws ZodError if validation fails
+ * @public
+ */
+export declare function parseField(data: unknown): FieldMeta;
+
+/**
+ * Mapping from PostgreSQL types to Stonecrop field types
+ * @public
+ */
+export declare const PG_TYPE_MAP: Record<PostgresType, FieldTemplate_2>;
+
+/**
+ * PostgreSQL types we handle during conversion
+ * @public
+ */
+export declare const PostgresType: z.ZodEnum<["text", "varchar", "char", "citext", "smallint", "integer", "bigint", "serial", "bigserial", "smallserial", "numeric", "decimal", "real", "double precision", "money", "boolean", "date", "time", "timetz", "timestamp", "timestamptz", "interval", "int4range", "int8range", "numrange", "daterange", "tsrange", "tstzrange", "bytea", "uuid", "json", "jsonb", "bit", "varbit", "xml", "unit", "cube", "unknown"]>;
+
+export declare type PostgresType = z.infer<typeof PostgresType>;
+
+/**
+ * Converts snake_case to camelCase
+ * @param snakeCase - Snake case string
+ * @returns Camel case string
+ * @public
+ * @example
+ * ```typescript
+ * snakeToCamel('user_email') // 'userEmail'
+ * snakeToCamel('created_at') // 'createdAt'
+ * ```
+ */
+export declare function snakeToCamel(snakeCase: string): string;
+
+/**
+ * Converts snake_case to Title Case label
+ * @param snakeCase - Snake case string
+ * @returns Title case label
+ * @public
+ * @example
+ * ```typescript
+ * snakeToLabel('user_email') // 'User Email'
+ * snakeToLabel('first_name') // 'First Name'
+ * ```
+ */
+export declare function snakeToLabel(snakeCase: string): string;
+
+/**
+ * Stonecrop field types - the semantic type of the field.
+ * These are consistent across forms and tables.
+ * @public
+ */
+declare const StonecropFieldType: z.ZodEnum<["Data", "Text", "Int", "Float", "Decimal", "Check", "Date", "Time", "Datetime", "Duration", "DateRange", "JSON", "Code", "Link", "Doctype", "Attach", "Currency", "Quantity", "Select"]>;
+
+declare type StonecropFieldType = z.infer<typeof StonecropFieldType>;
+export { StonecropFieldType }
+export { StonecropFieldType as StonecropFieldTypeValue }
+
+/**
+ * Convert table name to PascalCase doctype name
+ * @param tableName - SQL table name (snake_case)
+ * @returns PascalCase name
+ * @public
+ */
+export declare function toPascalCase(tableName: string): string;
+
+/**
+ * Convert to kebab-case slug
+ * @param name - Name to convert
+ * @returns kebab-case slug
+ * @public
+ */
+export declare function toSlug(name: string): string;
+
+/**
+ * PostgreSQL type aliases to canonical types
+ * @public
+ */
+export declare const TYPE_ALIASES: Record<string, PostgresType>;
+
+/**
+ * Mapping from StonecropFieldType to default Vue component.
+ * Components can be overridden in the field definition.
+ * @public
+ */
+export declare const TYPE_MAP: Record<StonecropFieldType, FieldTemplate>;
+
+/**
+ * Validate a doctype definition
+ * @param data - Data to validate
+ * @returns Validation result
+ * @public
+ */
+export declare function validateDoctype(data: unknown): ValidationResult;
+
+/**
+ * Validate a field definition
+ * @param data - Data to validate
+ * @returns Validation result
+ * @public
+ */
+export declare function validateField(data: unknown): ValidationResult;
+
+/**
+ * Validation error with path information
+ * @public
+ */
+export declare interface ValidationError {
+    /** Path to the invalid property */
+    path: (string | number)[];
+    /** Error message */
+    message: string;
+}
+
+/**
+ * Result of a validation operation
+ * @public
+ */
+export declare interface ValidationResult {
+    /** Whether validation passed */
+    success: boolean;
+    /** List of validation errors (empty if success) */
+    errors: ValidationError[];
+}
+
+/**
+ * Workflow metadata - states and actions for a doctype
+ * @public
+ */
+declare const WorkflowMeta: z.ZodObject<{
+    /** List of workflow states */
+    states: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Actions available in this workflow */
+    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 */
+        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;
+}>;
+
+declare type WorkflowMeta = z.infer<typeof WorkflowMeta>;
+export { WorkflowMeta }
+export { WorkflowMeta as WorkflowMetaType }
+
+export { }