@betterstart/cli 0.1.0

package/dist/config/index.d.ts

@@ -0,0 +1,178 @@
+export { I as ImportResolver } from '../import-resolver-BJOCLFnH.js';
+import { U as UserConfig, B as BetterstartConfig, R as ResolvedPaths, a as ResolvedConfig, I as ImportPaths, P as Preset } from '../types-BouTOvVr.js';
+export { k as BetterstartPlugin, C as CustomGenerator, c as DatabaseConfig, D as DatabaseProvider, l as DeepPartial, F as FieldTypeHandler, p as GenerateOptions, i as GeneratedFile, G as GeneratorConfig, f as GeneratorName, n as GeneratorOptions, o as InitOptions, O as OutputPaths, j as PluginCommand, h as PluginContext, g as PluginHooks, b as ProjectPaths, m as ProjectType, q as RemoveOptions, e as UIConfig, d as UIFramework } from '../types-BouTOvVr.js';
+import '../logger-awLb347n.js';
+
+/**
+ * Configuration loader for @betterstart/cli
+ * Handles loading, merging, and resolving configuration
+ */
+
+/**
+ * Supported configuration file names (in priority order)
+ */
+declare const CONFIG_FILE_NAMES: string[];
+/**
+ * Find the configuration file in a directory
+ * @param cwd - Directory to search in
+ * @returns Path to the config file or undefined if not found
+ */
+declare function findConfigFile(cwd: string): string | undefined;
+/**
+ * Load configuration from a file
+ * @param configPath - Path to the configuration file
+ * @returns The loaded configuration
+ */
+declare function loadConfigFile(configPath: string): Promise<UserConfig>;
+/**
+ * Load configuration from a directory
+ * Automatically finds and loads the config file, or uses defaults
+ *
+ * @param cwd - Directory to load config from (defaults to process.cwd())
+ * @param presetName - Optional preset name to use as base
+ * @returns The loaded and merged configuration
+ */
+declare function loadConfig(cwd?: string, presetName?: string): Promise<BetterstartConfig>;
+/**
+ * Find the project root directory
+ * Looks for common root indicators (package.json, pnpm-workspace.yaml, turbo.json)
+ *
+ * @param startDir - Directory to start searching from
+ * @returns The project root directory
+ */
+declare function findProjectRoot(startDir: string): string;
+/**
+ * Resolve configuration paths to absolute paths
+ *
+ * @param config - The configuration to resolve
+ * @param projectRoot - The project root directory
+ * @returns Configuration with resolved absolute paths
+ */
+declare function resolvePaths(config: BetterstartConfig, projectRoot: string): ResolvedPaths;
+/**
+ * Fully resolve configuration including paths
+ *
+ * @param config - The configuration to resolve
+ * @param projectRoot - The project root directory (optional, auto-detected if not provided)
+ * @returns Fully resolved configuration
+ */
+declare function resolveConfig(config: BetterstartConfig, projectRoot?: string): ResolvedConfig;
+/**
+ * Helper function for defining configuration in betterstart.config.ts
+ * Provides type checking and autocomplete
+ *
+ * @example
+ * ```ts
+ * // betterstart.config.ts
+ * import { defineConfig } from '@betterstart/cli'
+ *
+ * export default defineConfig({
+ *   paths: {
+ *     app: 'apps/web',
+ *     database: 'packages/database'
+ *   }
+ * })
+ * ```
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+/**
+ * Validate a configuration
+ * @param config - The configuration to validate
+ * @returns Array of validation errors (empty if valid)
+ */
+declare function validateConfig(config: BetterstartConfig): string[];
+/**
+ * Check if resolved paths exist and are accessible
+ * @param paths - The resolved paths to check
+ * @returns Object with path existence status
+ */
+declare function checkPaths(paths: ResolvedPaths): Record<keyof ResolvedPaths, boolean>;
+
+/**
+ * Project presets for common project structures
+ * Each preset provides default configuration for a specific project type
+ */
+
+/**
+ * Default output paths
+ */
+declare const DEFAULT_OUTPUT_PATHS: {
+    actions: string;
+    hooks: string;
+    components: string;
+    pages: string;
+    emails: string;
+};
+/**
+ * Default database configuration
+ */
+declare const DEFAULT_DATABASE_CONFIG: {
+    provider: "drizzle";
+    schemaFile: string;
+    migrationsDir: string;
+    autoMigrate: boolean;
+};
+/**
+ * Default UI configuration
+ */
+declare const DEFAULT_UI_CONFIG: {
+    framework: "shadcn";
+    components: {
+        path: string;
+        adminPath: string;
+    };
+};
+/**
+ * Monorepo import paths (for @betterstart/* packages)
+ */
+declare const MONOREPO_IMPORT_PATHS: ImportPaths;
+/**
+ * Standalone import paths (for @/ alias in single Next.js apps)
+ */
+declare const STANDALONE_IMPORT_PATHS: ImportPaths;
+/**
+ * Default generator configuration
+ */
+declare const DEFAULT_GENERATOR_CONFIG: {
+    core: string[];
+    optional: string[];
+};
+/**
+ * Next.js monorepo preset (Turborepo/pnpm style)
+ * Similar to the current betterstart structure
+ */
+declare const nextjsMonorepoPreset: Preset;
+/**
+ * Standalone Next.js preset
+ * For single Next.js apps without monorepo structure
+ */
+declare const nextjsStandalonePreset: Preset;
+/**
+ * Custom/minimal preset
+ * Provides minimal defaults, user must configure paths
+ */
+declare const customPreset: Preset;
+/**
+ * All available presets
+ */
+declare const presets: Record<string, Preset>;
+/**
+ * Get a preset by name
+ */
+declare function getPreset(name: string): Preset | undefined;
+/**
+ * Get all preset names
+ */
+declare function getPresetNames(): string[];
+/**
+ * Auto-detect the best preset for a project
+ * @param cwd - The project root directory
+ * @returns The detected preset or 'custom' if none match
+ */
+declare function detectPreset(cwd: string): Preset;
+/**
+ * Get the default configuration based on project detection
+ */
+declare function getDefaultConfig(cwd: string): UserConfig;
+
+export { BetterstartConfig, CONFIG_FILE_NAMES, DEFAULT_DATABASE_CONFIG, DEFAULT_GENERATOR_CONFIG, DEFAULT_OUTPUT_PATHS, DEFAULT_UI_CONFIG, ImportPaths, MONOREPO_IMPORT_PATHS, Preset, ResolvedConfig, ResolvedPaths, STANDALONE_IMPORT_PATHS, UserConfig, checkPaths, customPreset, defineConfig, detectPreset, findConfigFile, findProjectRoot, getDefaultConfig, getPreset, getPresetNames, loadConfig, loadConfigFile, nextjsMonorepoPreset, nextjsStandalonePreset, presets, resolveConfig, resolvePaths, validateConfig };

package/dist/config/index.js

@@ -0,0 +1,58 @@
+import {
+  CONFIG_FILE_NAMES,
+  checkPaths,
+  defineConfig,
+  findConfigFile,
+  findProjectRoot,
+  loadConfig,
+  loadConfigFile,
+  resolveConfig,
+  resolvePaths,
+  validateConfig
+} from "../chunk-46UVIUJF.js";
+import {
+  DEFAULT_DATABASE_CONFIG,
+  DEFAULT_GENERATOR_CONFIG,
+  DEFAULT_OUTPUT_PATHS,
+  DEFAULT_UI_CONFIG,
+  ImportResolver,
+  MONOREPO_IMPORT_PATHS,
+  STANDALONE_IMPORT_PATHS,
+  customPreset,
+  detectPreset,
+  getDefaultConfig,
+  getPreset,
+  getPresetNames,
+  nextjsMonorepoPreset,
+  nextjsStandalonePreset,
+  presets
+} from "../chunk-PWRI4LKM.js";
+import "../chunk-WY6BC55D.js";
+export {
+  CONFIG_FILE_NAMES,
+  DEFAULT_DATABASE_CONFIG,
+  DEFAULT_GENERATOR_CONFIG,
+  DEFAULT_OUTPUT_PATHS,
+  DEFAULT_UI_CONFIG,
+  ImportResolver,
+  MONOREPO_IMPORT_PATHS,
+  STANDALONE_IMPORT_PATHS,
+  checkPaths,
+  customPreset,
+  defineConfig,
+  detectPreset,
+  findConfigFile,
+  findProjectRoot,
+  getDefaultConfig,
+  getPreset,
+  getPresetNames,
+  loadConfig,
+  loadConfigFile,
+  nextjsMonorepoPreset,
+  nextjsStandalonePreset,
+  presets,
+  resolveConfig,
+  resolvePaths,
+  validateConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/core/index.d.ts

@@ -0,0 +1,415 @@
+import { a as SchemaField, b as FieldType, F as FormSchema, i as FormField } from '../types-ByX_gl6y.js';
+export { b as LogEntry, L as LogLevel, a as Logger, e as createBufferedLogger, c as createConsoleLogger, d as createSilentLogger, g as getLogger, l as logger, r as resetLogger, s as setLogger } from '../logger-awLb347n.js';
+
+/**
+ * Centralized constants for the codegen package
+ * These replace magic strings scattered throughout generators
+ */
+/**
+ * All supported field types for schema definitions
+ */
+declare const FIELD_TYPES: {
+    readonly STRING: "string";
+    readonly NUMBER: "number";
+    readonly BOOLEAN: "boolean";
+    readonly TEXT: "text";
+    readonly DECIMAL: "decimal";
+    readonly VARCHAR: "varchar";
+    readonly SERIAL: "serial";
+    readonly DATE: "date";
+    readonly TIMESTAMP: "timestamp";
+    readonly TIME: "time";
+    readonly MARKDOWN: "markdown";
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly MEDIA: "media";
+    readonly ICON: "icon";
+    readonly GROUP: "group";
+    readonly TABS: "tabs";
+    readonly LIST: "list";
+    readonly SEPARATOR: "separator";
+    readonly SELECT: "select";
+    readonly RELATIONSHIP: "relationship";
+    readonly CURRICULUM: "curriculum";
+};
+/**
+ * Field types that contain nested fields
+ */
+declare const NESTED_FIELD_TYPES: readonly ["group", "tabs", "list"];
+/**
+ * Field types that represent rich text content
+ */
+declare const RICH_TEXT_FIELD_TYPES: readonly ["markdown", "text"];
+/**
+ * Field types that are stored as long text in the database
+ */
+declare const LONG_TEXT_FIELD_TYPES: readonly ["text", "markdown", "list", "media", "video", "curriculum"];
+/**
+ * All supported column types for admin tables
+ */
+declare const COLUMN_TYPES: {
+    readonly TEXT: "text";
+    readonly BADGE: "badge";
+    readonly DATE: "date";
+    readonly CUSTOM: "custom";
+    readonly AVATAR: "avatar";
+    readonly LINK: "link";
+    readonly IMAGE: "image";
+    readonly EMAIL: "email";
+    readonly NUMBER: "number";
+    readonly BOOLEAN: "boolean";
+};
+/**
+ * All supported form field types
+ */
+declare const FORM_FIELD_TYPES: {
+    readonly TEXT: "text";
+    readonly TEXTAREA: "textarea";
+    readonly EMAIL: "email";
+    readonly PHONE: "phone";
+    readonly NUMBER: "number";
+    readonly URL: "url";
+    readonly DATE: "date";
+    readonly SELECT: "select";
+    readonly RADIO: "radio";
+    readonly CHECKBOX: "checkbox";
+    readonly MULTISELECT: "multiselect";
+    readonly FILE: "file";
+    readonly UPLOAD: "upload";
+    readonly GROUP: "group";
+    readonly TIMEZONE: "timezone";
+    readonly LIST: "list";
+};
+/**
+ * Fields that are automatically added to schemas
+ */
+declare const AUTO_FIELDS: {
+    readonly ID: "id";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+    readonly PUBLISHED: "published";
+    readonly SLUG: "slug";
+};
+/**
+ * Fields automatically added for form submissions
+ */
+declare const FORM_SUBMISSION_FIELDS: {
+    readonly SUBMITTED_AT: "submittedAt";
+    readonly IP_ADDRESS: "ipAddress";
+    readonly USER_AGENT: "userAgent";
+};
+/**
+ * Default Drizzle column configurations
+ */
+declare const DRIZZLE_DEFAULTS: {
+    readonly VARCHAR_LENGTH: 255;
+    readonly DECIMAL_PRECISION: 10;
+    readonly DECIMAL_SCALE: 2;
+};
+/**
+ * Core generators that are always included
+ */
+declare const CORE_GENERATORS: readonly ["database", "actions", "hooks", "columns", "table", "page", "page-content", "form", "create-page", "edit-page", "navigation"];
+/**
+ * Optional generators that can be enabled via config
+ */
+declare const OPTIONAL_GENERATORS: readonly [];
+declare const FILE_EXTENSIONS: {
+    readonly TYPESCRIPT: ".ts";
+    readonly TSX: ".tsx";
+    readonly JSON: ".json";
+    readonly SQL: ".sql";
+};
+type FieldTypeValue = (typeof FIELD_TYPES)[keyof typeof FIELD_TYPES];
+type ColumnTypeValue = (typeof COLUMN_TYPES)[keyof typeof COLUMN_TYPES];
+type FormFieldTypeValue = (typeof FORM_FIELD_TYPES)[keyof typeof FORM_FIELD_TYPES];
+/**
+ * Check if a value is a valid field type
+ */
+declare function isFieldType(value: string): value is FieldTypeValue;
+/**
+ * Check if a field type contains nested fields
+ */
+declare function isNestedFieldType(type: string): boolean;
+/**
+ * Check if a field type is stored as long text
+ */
+declare function isLongTextFieldType(type: string): boolean;
+
+/**
+ * Custom error classes for the codegen package
+ * Provides structured errors with codes and context for better debugging
+ */
+/**
+ * Base error class for all codegen errors
+ */
+declare class CodegenError extends Error {
+    readonly code: string;
+    readonly context?: unknown;
+    constructor(message: string, code: string, context?: unknown);
+    /**
+     * Format error for display
+     */
+    toString(): string;
+}
+/**
+ * Error thrown when schema validation fails
+ */
+declare class SchemaValidationError extends CodegenError {
+    readonly validationErrors: string[];
+    constructor(message: string, validationErrors: string[], context?: unknown);
+    toString(): string;
+}
+/**
+ * Error thrown when configuration is invalid or missing
+ */
+declare class ConfigurationError extends CodegenError {
+    constructor(message: string, context?: unknown);
+}
+/**
+ * Error thrown during code generation
+ */
+declare class GeneratorError extends CodegenError {
+    readonly generatorName: string;
+    constructor(message: string, generatorName: string, context?: unknown);
+    toString(): string;
+}
+/**
+ * Error thrown when a plugin fails
+ */
+declare class PluginError extends CodegenError {
+    readonly pluginName: string;
+    constructor(message: string, pluginName: string, context?: unknown);
+    toString(): string;
+}
+/**
+ * Error thrown when a file operation fails
+ */
+declare class FileOperationError extends CodegenError {
+    readonly filePath: string;
+    readonly operation: 'read' | 'write' | 'delete' | 'create';
+    constructor(message: string, filePath: string, operation: 'read' | 'write' | 'delete' | 'create', context?: unknown);
+    toString(): string;
+}
+/**
+ * Error thrown when a required field is missing
+ */
+declare class MissingFieldError extends CodegenError {
+    readonly fieldName: string;
+    readonly schemaName: string;
+    constructor(fieldName: string, schemaName: string, context?: unknown);
+}
+/**
+ * Error thrown when a field type is not supported
+ */
+declare class UnsupportedFieldTypeError extends CodegenError {
+    readonly fieldType: string;
+    readonly fieldName: string;
+    constructor(fieldType: string, fieldName: string, context?: unknown);
+}
+declare const ERROR_CODES: {
+    readonly SCHEMA_VALIDATION_ERROR: "SCHEMA_VALIDATION_ERROR";
+    readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+    readonly GENERATOR_ERROR: "GENERATOR_ERROR";
+    readonly PLUGIN_ERROR: "PLUGIN_ERROR";
+    readonly FILE_OPERATION_ERROR: "FILE_OPERATION_ERROR";
+    readonly MISSING_FIELD_ERROR: "MISSING_FIELD_ERROR";
+    readonly UNSUPPORTED_FIELD_TYPE_ERROR: "UNSUPPORTED_FIELD_TYPE_ERROR";
+};
+/**
+ * Check if an error is a CodegenError
+ */
+declare function isCodegenError(error: unknown): error is CodegenError;
+/**
+ * Wrap an unknown error in a CodegenError
+ */
+declare function wrapError(error: unknown, code: string, message?: string): CodegenError;
+
+/**
+ * Field helper utilities for the codegen package
+ * Consolidates duplicated field-checking functions from actions.ts, form.ts, etc.
+ */
+
+/**
+ * Options for walking the field tree
+ */
+interface WalkFieldsOptions {
+    /** Include fields inside list items */
+    includeLists?: boolean;
+    /** Include fields inside groups */
+    includeGroups?: boolean;
+    /** Include fields inside tabs */
+    includeTabs?: boolean;
+}
+/**
+ * Walk through all fields in a schema, including nested ones
+ * @param fields - The fields to walk
+ * @param callback - Called for each field with depth and parent info
+ * @param options - Control which nested structures to traverse
+ */
+declare function walkFields(fields: SchemaField[], callback: (field: SchemaField, depth: number, parent?: SchemaField) => void, options?: WalkFieldsOptions): void;
+/**
+ * Check if any field in the tree matches a specific type
+ * Replaces the many checkForFieldType() functions
+ */
+declare function hasFieldType(fields: SchemaField[], type: FieldType | string, options?: WalkFieldsOptions): boolean;
+/**
+ * Check if any field in the tree matches any of the given types
+ */
+declare function hasAnyFieldType(fields: SchemaField[], types: (FieldType | string)[], options?: WalkFieldsOptions): boolean;
+/**
+ * Check if any field uses icons (either icon type or hasIcon property)
+ * Replaces checkForIconUsage() from form.ts
+ */
+declare function hasIconUsage(fields: SchemaField[], options?: WalkFieldsOptions): boolean;
+/**
+ * Check if any field is a relationship field
+ * Replaces checkForRelationshipField() from form.ts
+ */
+declare function hasRelationshipField(fields: SchemaField[], options?: WalkFieldsOptions): boolean;
+/**
+ * Check if any field is a markdown field
+ * Replaces checkForMarkdownField() from form.ts
+ */
+declare function hasMarkdownField(fields: SchemaField[], options?: WalkFieldsOptions): boolean;
+/**
+ * Check if any field is a textarea/text field
+ * Replaces checkForTextareaField() from form.ts
+ */
+declare function hasTextareaField(fields: SchemaField[], options?: WalkFieldsOptions): boolean;
+/**
+ * Collect all fields of a specific type
+ */
+declare function collectFieldsByType(fields: SchemaField[], type: FieldType | string, options?: WalkFieldsOptions): SchemaField[];
+/**
+ * Get all many-to-many relationship fields
+ * Replaces getManyToManyFields() from actions.ts and database.ts
+ */
+declare function getManyToManyFields(fields: SchemaField[]): SchemaField[];
+/**
+ * Get all relationship fields (excluding many-to-many)
+ * Replaces _getNestedRelationshipFields() from actions.ts
+ */
+declare function getNestedRelationshipFields(fields: SchemaField[], options?: WalkFieldsOptions): SchemaField[];
+/**
+ * Collect relationship fields from top-level and groups only (not lists)
+ * Used for form imports where list relationships use different handling
+ */
+declare function collectRelationshipFieldsTopLevel(fields: SchemaField[]): SchemaField[];
+/**
+ * Collect ALL relationship fields including those in lists
+ * Used for data hooks
+ */
+declare function collectAllRelationshipFields(fields: SchemaField[]): SchemaField[];
+/**
+ * Get list fields that have nested fields (not just items)
+ */
+declare function getListFieldsWithNestedFields(fields: SchemaField[]): SchemaField[];
+/**
+ * Get nested list fields (list fields inside list fields)
+ */
+declare function getNestedListFields(fields: SchemaField[]): {
+    parent: SchemaField;
+    nested: SchemaField;
+}[];
+/**
+ * Ensure fields have an ID field - automatically injects one if not present
+ */
+declare function ensureIdField(fields: SchemaField[]): SchemaField[];
+/**
+ * Flatten group and tabs fields into individual fields for database operations
+ * Automatically ensures an ID field exists
+ */
+declare function flattenFields(fields: SchemaField[]): SchemaField[];
+/**
+ * Get all fields from a form schema (including from steps)
+ * Replaces getAllFields() from email-template.ts and form-generator.ts
+ */
+declare function getAllFormFields(schema: FormSchema): FormField[];
+/**
+ * Check if a form schema is multi-step
+ */
+declare function isMultiStepForm(schema: FormSchema): boolean;
+/**
+ * Result of analyzing all field types in a schema
+ */
+interface FieldAnalysis {
+    hasBoolean: boolean;
+    hasImage: boolean;
+    hasVideo: boolean;
+    hasMedia: boolean;
+    hasDate: boolean;
+    hasList: boolean;
+    hasNestedList: boolean;
+    hasSelect: boolean;
+    hasMarkdown: boolean;
+    hasTextarea: boolean;
+    hasSeparator: boolean;
+    hasIcon: boolean;
+    hasRelationship: boolean;
+    hasManyToMany: boolean;
+    fieldTypes: Set<string>;
+}
+/**
+ * Analyze all field types in a schema
+ * Returns a comprehensive analysis that can be used to determine imports, etc.
+ */
+declare function analyzeFields(fields: SchemaField[]): FieldAnalysis;
+
+/**
+ * Type mapping utilities for the codegen package
+ * Consolidates type mapping functions from form.ts, database.ts, actions.ts, form-generator.ts
+ */
+
+/**
+ * Map a schema field type to Drizzle ORM column type
+ * @param field - The schema field
+ * @param requiredImports - Set to track which Drizzle imports are needed
+ * @returns The Drizzle column type expression
+ */
+declare function toDrizzleType(field: SchemaField, requiredImports: Set<string>): string;
+/**
+ * Map a schema field type to Zod validation schema
+ * @param field - The schema field
+ * @returns The Zod schema expression as a string
+ */
+declare function toZodType(field: SchemaField): string;
+/**
+ * Map a schema field type to TypeScript type
+ * @param field - The schema field
+ * @param mode - 'input' for form input types, 'output' for database output types
+ * @returns The TypeScript type as a string
+ */
+declare function toTypeScriptType(field: SchemaField, mode?: 'input' | 'output'): string;
+/**
+ * Map a schema field type to HTML form input type
+ * @param field - The schema field
+ * @returns The form input type (checkbox, textarea, number, date, etc.)
+ */
+declare function toFormFieldType(field: SchemaField): string;
+/**
+ * Map a form field type to Drizzle ORM column type
+ * @param field - The form field
+ * @param requiredImports - Set to track which Drizzle imports are needed
+ * @returns The Drizzle column type expression
+ */
+declare function formFieldToDrizzleType(field: FormField, requiredImports: Set<string>): string;
+interface FormFieldZodOptions {
+    /** Treat field as optional even if required (for conditional fields) */
+    treatAsOptional?: boolean;
+}
+/**
+ * Map a form field type to Zod validation schema
+ * @param field - The form field
+ * @param options - Options for generating the zod type
+ * @returns The Zod schema expression as a string
+ */
+declare function formFieldToZodType(field: FormField, options?: FormFieldZodOptions): string;
+/**
+ * Map a schema field type to SQL column type
+ * @param field - The schema field
+ * @returns The SQL column type
+ */
+declare function toSQLType(field: SchemaField): string;
+
+export { AUTO_FIELDS, COLUMN_TYPES, CORE_GENERATORS, CodegenError, type ColumnTypeValue, ConfigurationError, DRIZZLE_DEFAULTS, ERROR_CODES, FIELD_TYPES, FILE_EXTENSIONS, FORM_FIELD_TYPES, FORM_SUBMISSION_FIELDS, type FieldAnalysis, type FieldTypeValue, FileOperationError, type FormFieldTypeValue, type FormFieldZodOptions, GeneratorError, LONG_TEXT_FIELD_TYPES, MissingFieldError, NESTED_FIELD_TYPES, OPTIONAL_GENERATORS, PluginError, RICH_TEXT_FIELD_TYPES, SchemaValidationError, UnsupportedFieldTypeError, type WalkFieldsOptions, analyzeFields, collectAllRelationshipFields, collectFieldsByType, collectRelationshipFieldsTopLevel, ensureIdField, flattenFields, formFieldToDrizzleType, formFieldToZodType, getAllFormFields, getListFieldsWithNestedFields, getManyToManyFields, getNestedListFields, getNestedRelationshipFields, hasAnyFieldType, hasFieldType, hasIconUsage, hasMarkdownField, hasRelationshipField, hasTextareaField, isCodegenError, isFieldType, isLongTextFieldType, isMultiStepForm, isNestedFieldType, toDrizzleType, toFormFieldType, toSQLType, toTypeScriptType, toZodType, walkFields, wrapError };