@stonecrop/schema 0.8.7 → 0.8.9

package/dist/src/converter/heuristics.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Default heuristics for identifying entity types and fields in a GraphQL schema.
+ *
+ * These heuristics work across common GraphQL servers (PostGraphile, Hasura, Apollo, etc.)
+ * by detecting widely-adopted conventions like the Relay connection pattern.
+ *
+ * All heuristics can be overridden via the `isEntityType`, `isEntityField`, and
+ * `classifyField` options in `GraphQLConversionOptions`.
+ *
+ * @packageDocumentation
+ */
+import { type GraphQLObjectType, type GraphQLField } from 'graphql';
+import type { GraphQLConversionFieldMeta, GraphQLConversionOptions } from './types';
+/**
+ * Default heuristic to determine if a GraphQL object type represents an entity.
+ * An entity type becomes a Stonecrop doctype.
+ *
+ * This heuristic excludes:
+ * - Introspection types (`__*`)
+ * - Root operation types (`Query`, `Mutation`, `Subscription`)
+ * - Types with synthetic suffixes (e.g., `*Connection`, `*Edge`, `*Input`)
+ * - Types starting with `Node` interface marker (exact match only)
+ *
+ * @param typeName - The GraphQL type name
+ * @param type - The GraphQL object type definition
+ * @returns `true` if this type should become a Stonecrop doctype
+ * @public
+ */
+export declare function defaultIsEntityType(typeName: string, type: GraphQLObjectType): boolean;
+/**
+ * Default heuristic to filter fields on entity types.
+ * Skips internal fields that don't represent meaningful data.
+ *
+ * @param fieldName - The GraphQL field name
+ * @param _field - The GraphQL field definition (unused in default implementation)
+ * @param _parentType - The parent entity type (unused in default implementation)
+ * @returns `true` if this field should be included
+ * @public
+ */
+export declare function defaultIsEntityField(fieldName: string, _field: GraphQLField<unknown, unknown>, _parentType: GraphQLObjectType): boolean;
+/**
+ * Classify a single GraphQL field into a Stonecrop field definition.
+ *
+ * Classification rules (in order):
+ * 1. Scalar types → look up in merged scalar map
+ * 2. Enum types → `Select` with enum values as options
+ * 3. Object types that are entities → `Link` with slug as options
+ * 4. Object types that are Connections → `Doctype` with node type slug as options
+ * 5. List of entity type → `Doctype` with item type slug as options
+ * 6. Anything else → `Data` with `_unmapped: true`
+ *
+ * @param fieldName - The GraphQL field name
+ * @param field - The GraphQL field definition
+ * @param entityTypes - Set of type names classified as entities
+ * @param options - Conversion options (for custom scalars, unmapped meta, etc.)
+ * @returns The Stonecrop field definition
+ * @public
+ */
+export declare function classifyFieldType(fieldName: string, field: GraphQLField<unknown, unknown>, entityTypes: Set<string>, options?: GraphQLConversionOptions): GraphQLConversionFieldMeta;
+//# sourceMappingURL=heuristics.d.ts.map

package/dist/src/converter/heuristics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristics.d.ts","sourceRoot":"","sources":["../../../src/converter/heuristics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAMN,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAGjB,MAAM,SAAS,CAAA;AAGhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AA+BnF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CA8BtF;AAQD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACtC,WAAW,EAAE,iBAAiB,GAC5B,OAAO,CAET;AAsED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,OAAO,GAAE,wBAA6B,GACpC,0BAA0B,CAyF5B"}

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

@@ -0,0 +1,47 @@
+/**
+ * GraphQL Introspection to Stonecrop Schema Converter
+ *
+ * Converts a standard GraphQL introspection result (or SDL string) into
+ * Stonecrop doctype schemas. Source-agnostic — works with any GraphQL server.
+ *
+ * @packageDocumentation
+ */
+import type { IntrospectionSource, GraphQLConversionOptions, ConvertedGraphQLDoctype } from './types';
+/**
+ * Convert a GraphQL schema to Stonecrop doctype schemas.
+ *
+ * Accepts either an `IntrospectionQuery` result object or an SDL string.
+ * Entity types are identified using heuristics (or a custom `isEntityType` function)
+ * and converted to `DoctypeMeta`-compatible JSON objects.
+ *
+ * @param source - GraphQL introspection result or SDL string
+ * @param options - Conversion options for controlling output format and behavior
+ * @returns Array of converted Stonecrop doctype definitions
+ *
+ * @example
+ * ```typescript
+ * // From introspection result (fetched from any GraphQL server)
+ * const introspection = await fetchIntrospection('http://localhost:5000/graphql')
+ * const doctypes = convertGraphQLSchema(introspection)
+ *
+ * // From SDL string
+ * const sdl = fs.readFileSync('schema.graphql', 'utf-8')
+ * const doctypes = convertGraphQLSchema(sdl)
+ *
+ * // With PostGraphile custom scalars
+ * const doctypes = convertGraphQLSchema(introspection, {
+ *   customScalars: {
+ *     BigFloat: { component: 'ADecimalInput', fieldtype: 'Decimal' }
+ *   }
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function convertGraphQLSchema(source: IntrospectionSource, options?: GraphQLConversionOptions): ConvertedGraphQLDoctype[];
+export { convertGraphQLSchema as default };
+export type { IntrospectionSource, GraphQLConversionOptions, GraphQLConversionFieldMeta, ConvertedGraphQLDoctype, } from './types';
+export { GQL_SCALAR_MAP, WELL_KNOWN_SCALARS, INTERNAL_SCALARS, buildScalarMap } from './scalars';
+export { defaultIsEntityType, defaultIsEntityField, classifyFieldType } from './heuristics';
+export { toSlug, toPascalCase, pascalToSnake, snakeToCamel, camelToSnake, snakeToLabel, camelToLabel } from '../naming';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/converter/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA;AAGrG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,GAAE,wBAA6B,GACpC,uBAAuB,EAAE,CA8G3B;AAwBD,OAAO,EAAE,oBAAoB,IAAI,OAAO,EAAE,CAAA;AAG1C,YAAY,EACX,mBAAmB,EACnB,wBAAwB,EACxB,0BAA0B,EAC1B,uBAAuB,GACvB,MAAM,SAAS,CAAA;AAGhB,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAGhG,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAG3F,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA"}

package/dist/src/converter/scalars.d.ts

@@ -0,0 +1,46 @@
+/**
+ * GraphQL Scalar Type Mappings
+ *
+ * Maps standard GraphQL scalars and well-known custom scalars to Stonecrop field types.
+ * Source-agnostic — covers scalars commonly emitted by PostGraphile, Hasura, Apollo, etc.
+ *
+ * Users can extend these via the `customScalars` option in `GraphQLConversionOptions`.
+ *
+ * @packageDocumentation
+ */
+import type { FieldTemplate } from '../fieldtype';
+/**
+ * Mapping from standard GraphQL scalar types to Stonecrop field types.
+ * These are defined by the GraphQL specification and are always available.
+ *
+ * @public
+ */
+export declare const GQL_SCALAR_MAP: Record<string, FieldTemplate>;
+/**
+ * Mapping from well-known custom GraphQL scalars to Stonecrop field types.
+ * These cover scalars commonly used across GraphQL servers (PostGraphile, Hasura, etc.)
+ * without baking in knowledge of any specific server.
+ *
+ * Entries here have lower precedence than `customScalars` from options, but higher
+ * precedence than unknown/unmapped scalars.
+ *
+ * @public
+ */
+export declare const WELL_KNOWN_SCALARS: Record<string, FieldTemplate>;
+/**
+ * Set of scalar type names that are internal to GraphQL servers and should be skipped
+ * during field conversion (they don't represent meaningful data fields).
+ *
+ * @public
+ */
+export declare const INTERNAL_SCALARS: Set<string>;
+/**
+ * Build a merged scalar map from the built-in maps and user-provided custom scalars.
+ * Precedence (highest to lowest): customScalars → GQL_SCALAR_MAP → WELL_KNOWN_SCALARS
+ *
+ * @param customScalars - User-provided scalar overrides
+ * @returns Merged scalar map
+ * @internal
+ */
+export declare function buildScalarMap(customScalars?: Record<string, Partial<FieldTemplate>>): Record<string, FieldTemplate>;
+//# sourceMappingURL=scalars.d.ts.map

package/dist/src/converter/scalars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalars.d.ts","sourceRoot":"","sources":["../../../src/converter/scalars.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAMxD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAuB5D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,aAAsB,CAAA;AAEnD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAmBpH"}

package/dist/src/converter/types.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Types for the GraphQL introspection to Stonecrop schema converter.
+ * Source-agnostic — works with any GraphQL server (PostGraphile, Hasura, Apollo, etc.)
+ * @packageDocumentation
+ */
+import type { IntrospectionQuery } from 'graphql';
+import type { GraphQLObjectType, GraphQLField } from 'graphql';
+import type { FieldMeta } from '../field';
+import type { FieldTemplate } from '../fieldtype';
+/**
+ * Input source for the GraphQL schema converter.
+ * Accepts either a standard GraphQL introspection result or an SDL string.
+ *
+ * - `IntrospectionQuery`: The raw result of a GraphQL introspection query (from any server)
+ * - `string`: An SDL (Schema Definition Language) string
+ *
+ * Note: URL fetching is intentionally not supported in the library API.
+ * Use the CLI (`stonecrop-schema generate --endpoint <url>`) for endpoint fetching,
+ * or fetch the introspection result yourself and pass it in.
+ *
+ * @public
+ */
+export type IntrospectionSource = IntrospectionQuery | string;
+/**
+ * Options for converting a GraphQL schema to Stonecrop doctype schemas.
+ * All hooks are optional — sensible defaults are provided for common GraphQL patterns.
+ *
+ * @public
+ */
+export interface GraphQLConversionOptions {
+    /**
+     * GraphQL type names to exclude from conversion.
+     * Applied after `isEntityType` filtering.
+     */
+    exclude?: string[];
+    /**
+     * Whitelist of GraphQL type names to convert.
+     * When provided, only these types are considered (after `isEntityType` filtering).
+     */
+    include?: string[];
+    /**
+     * Per-type, per-field overrides for the converted field definitions.
+     * Outer key is the GraphQL type name, inner key is the field name.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   SalesOrder: {
+     *     totalAmount: { fieldtype: 'Currency', component: 'ACurrencyInput' }
+     *   }
+     * }
+     * ```
+     */
+    typeOverrides?: Record<string, Record<string, Partial<FieldMeta>>>;
+    /**
+     * Map custom or non-standard GraphQL scalar types to Stonecrop field types.
+     * Merged with the built-in scalar maps (GQL_SCALAR_MAP + WELL_KNOWN_SCALARS).
+     * User-provided entries take highest precedence.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   MyCustomMoney: { component: 'ACurrencyInput', fieldtype: 'Currency' },
+     *   PostGISPoint: { component: 'ATextInput', fieldtype: 'Data' }
+     * }
+     * ```
+     */
+    customScalars?: Record<string, Partial<FieldTemplate>>;
+    /**
+     * Custom function to determine if a GraphQL object type represents an entity (→ doctype).
+     * When provided, replaces the default heuristic entirely.
+     *
+     * The default heuristic excludes types matching synthetic patterns:
+     * `*Connection`, `*Edge`, `*Input`, `*Patch`, `*Payload`, `*Condition`,
+     * `*Filter`, `*OrderBy`, `*Aggregate`, `Query`, `Mutation`, `Subscription`, `__*`.
+     *
+     * @param typeName - The GraphQL type name
+     * @param type - The full GraphQL object type definition
+     * @returns `true` if this type should become a Stonecrop doctype
+     */
+    isEntityType?: (typeName: string, type: GraphQLObjectType) => boolean;
+    /**
+     * Custom function to filter which fields on an entity type are included.
+     * When provided, replaces the default field filter.
+     *
+     * The default filter excludes `nodeId`, `__typename`, and `clientMutationId`.
+     *
+     * @param fieldName - The GraphQL field name
+     * @param field - The full GraphQL field definition
+     * @param parentType - The parent entity type
+     * @returns `true` if this field should be included
+     */
+    isEntityField?: (fieldName: string, field: GraphQLField<unknown, unknown>, parentType: GraphQLObjectType) => boolean;
+    /**
+     * Escape hatch: fully override the classification of a specific field.
+     * When this returns a non-null value, it is used as the field definition
+     * (merged with the field name). Return `null` to fall through to default classification.
+     *
+     * @param fieldName - The GraphQL field name
+     * @param field - The full GraphQL field definition
+     * @param parentType - The parent entity type
+     * @returns Partial field meta to use, or `null` for default behavior
+     */
+    classifyField?: (fieldName: string, field: GraphQLField<unknown, unknown>, parentType: GraphQLObjectType) => Partial<FieldMeta> | null;
+    /**
+     * Custom function to derive the database table name from a GraphQL type name.
+     * The default converts PascalCase to snake_case (e.g., `SalesOrder` → `sales_order`).
+     *
+     * Return `undefined` to omit `tableName` from the output.
+     *
+     * @param typeName - The GraphQL type name
+     * @returns The derived table name, or `undefined`
+     */
+    deriveTableName?: (typeName: string) => string | undefined;
+    /**
+     * Include `_graphqlType` and `_unmapped` metadata on converted fields.
+     * Useful for debugging conversions. Defaults to `false`.
+     */
+    includeUnmappedMeta?: boolean;
+}
+/**
+ * Extended field metadata with optional GraphQL conversion metadata.
+ * Only present when `includeUnmappedMeta` is enabled.
+ *
+ * @public
+ */
+export interface GraphQLConversionFieldMeta extends FieldMeta {
+    /** Original GraphQL type name (for debugging/reference) */
+    _graphqlType?: string;
+    /** Marks fields that couldn't be automatically mapped */
+    _unmapped?: boolean;
+}
+/**
+ * Output of GraphQL schema conversion — one per entity type.
+ *
+ * @public
+ */
+export interface ConvertedGraphQLDoctype extends Omit<DoctypeMeta, 'fields'> {
+    /** Field definitions with optional GraphQL conversion metadata */
+    fields: GraphQLConversionFieldMeta[];
+    /** Original GraphQL type name (for debugging/reference) */
+    _graphqlTypeName?: string;
+}
+import type { DoctypeMeta } from '../doctype';
+//# sourceMappingURL=types.d.ts.map

package/dist/src/converter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/converter/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,GAAG,MAAM,CAAA;AAE7D;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAElB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAElB;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;IAElE;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IAEtD;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,KAAK,OAAO,CAAA;IAErE;;;;;;;;;;OAUG;IACH,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,UAAU,EAAE,iBAAiB,KAAK,OAAO,CAAA;IAEpH;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,CACf,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,UAAU,EAAE,iBAAiB,KACzB,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAAA;IAE9B;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;IAE1D;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA2B,SAAQ,SAAS;IAC5D,2DAA2D;IAC3D,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yDAAyD;IACzD,SAAS,CAAC,EAAE,OAAO,CAAA;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAwB,SAAQ,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC3E,kEAAkE;IAClE,MAAM,EAAE,0BAA0B,EAAE,CAAA;IACpC,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACzB;AAGD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA"}

package/dist/src/doctype.d.ts

@@ -0,0 +1,312 @@
+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;
+}>;
+/**
+ * Action definition type inferred from Zod schema
+ * @public
+ */
+export type ActionDefinition = z.infer<typeof ActionDefinition>;
+/**
+ * Workflow metadata - states and actions for a doctype
+ * @public
+ */
+export 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;
+}>;
+/**
+ * Workflow metadata type inferred from Zod schema
+ * @public
+ */
+export type WorkflowMeta = z.infer<typeof WorkflowMeta>;
+/**
+ * Doctype metadata - complete definition of a doctype
+ * @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"]>;
+        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;
+}>;
+/**
+ * Doctype metadata type inferred from Zod schema
+ * @public
+ */
+export type DoctypeMeta = z.infer<typeof DoctypeMeta>;
+//# sourceMappingURL=doctype.d.ts.map

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

@@ -0,0 +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"}