@famgia/omnify-core 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,987 @@
+import { ErrorCode, ErrorLocation, OmnifyErrorInfo, LoadedSchema, SchemaCollection, SchemaDefinition, PropertyDefinition, PluginLogger, CustomTypeDefinition, OmnifyPlugin, OmnifyConfig, AssociationDefinition } from '@famgia/omnify-types';
+export { AssociationRelation, CustomTypeDefinition, DatabaseConfig, ErrorCode, ErrorLocation, LoadedSchema, OmnifyConfig, OmnifyErrorInfo, OmnifyPlugin, OutputConfig, PropertyDefinition, PropertyType, Result, SchemaCollection, SchemaDefinition, SchemaOptions, err, ok } from '@famgia/omnify-types';
+
+/**
+ * @famgia/omnify-core - OmnifyError Class
+ *
+ * Base error class for all omnify errors with file:line:message:suggestion format.
+ */
+
+/**
+ * Base error class for omnify-schema.
+ * Provides consistent error formatting with source location and suggestions.
+ *
+ * @example
+ * ```typescript
+ * throw new OmnifyError(
+ *   "Invalid property type 'Stringg'",
+ *   'E201',
+ *   { file: 'schemas/User.yaml', line: 15, column: 10 },
+ *   "Did you mean 'String'?"
+ * );
+ * ```
+ */
+declare class OmnifyError extends Error {
+    /** Error code (e.g., 'E201') */
+    readonly code: ErrorCode;
+    /** Source location where the error occurred */
+    readonly location?: ErrorLocation;
+    /** Suggested fix for the error */
+    readonly suggestion?: string;
+    /** Additional context or details */
+    readonly details?: Record<string, unknown>;
+    /** Original error if this wraps another error */
+    readonly cause?: Error;
+    constructor(message: string, code: ErrorCode, location?: ErrorLocation, suggestion?: string, options?: {
+        details?: Record<string, unknown>;
+        cause?: Error;
+    });
+    /**
+     * Creates an OmnifyError from an OmnifyErrorInfo object.
+     */
+    static fromInfo(info: OmnifyErrorInfo): OmnifyError;
+    /**
+     * Wraps an unknown error as an OmnifyError.
+     * Useful for catching and re-throwing with context.
+     */
+    static wrap(error: unknown, code?: ErrorCode, location?: ErrorLocation): OmnifyError;
+    /**
+     * Converts to OmnifyErrorInfo for serialization.
+     */
+    toInfo(): OmnifyErrorInfo;
+    /**
+     * Returns a formatted string representation.
+     * Format: "Error [CODE]: message\n  --> file:line:column"
+     */
+    toString(): string;
+    /**
+     * Returns the file path from location, if available.
+     */
+    get file(): string | undefined;
+    /**
+     * Returns the line number from location, if available.
+     */
+    get line(): number | undefined;
+    /**
+     * Returns the column number from location, if available.
+     */
+    get column(): number | undefined;
+}
+
+/**
+ * @famgia/omnify-core - Error Formatter
+ *
+ * Formats errors for CLI output with optional ANSI colors.
+ */
+
+/**
+ * Options for error formatting.
+ */
+interface FormatOptions {
+    /** Enable ANSI color codes */
+    readonly color?: boolean;
+    /** Show source context lines */
+    readonly showContext?: boolean;
+    /** Number of context lines to show */
+    readonly contextLines?: number;
+    /** Source file content (for showing context) */
+    readonly sourceContent?: string;
+}
+/**
+ * Formats an OmnifyError for CLI output.
+ *
+ * @example Output:
+ * ```
+ * error[E201]: Invalid property type 'Stringg'
+ *   --> schemas/User.yaml:15:10
+ *    |
+ * 15 |     type: Stringg
+ *    |           ^^^^^^^ Did you mean 'String'?
+ *    |
+ *   = suggestion: Use one of: String, Int, Boolean, Text, ...
+ * ```
+ */
+declare function formatError(error: OmnifyError, options?: FormatOptions): string;
+/**
+ * Formats multiple errors as a summary.
+ */
+declare function formatErrorSummary(errors: readonly OmnifyError[], options?: FormatOptions): string;
+/**
+ * Formats an error for plain text output (no colors).
+ */
+declare function formatErrorPlain(error: OmnifyError): string;
+/**
+ * Gets the exit code for an error based on its code category.
+ */
+declare function getExitCode(error: OmnifyError): number;
+
+/**
+ * @famgia/omnify-core - Error Factory Functions
+ *
+ * Convenient factory functions for creating common error types.
+ */
+
+/**
+ * Creates a configuration error.
+ */
+declare function configError(message: string, code?: ErrorCode, suggestion?: string): OmnifyError;
+/**
+ * Config file not found error.
+ */
+declare function configNotFoundError(configPath: string): OmnifyError;
+/**
+ * Invalid config format error.
+ */
+declare function invalidConfigError(message: string, configPath: string): OmnifyError;
+/**
+ * Missing required config field error.
+ */
+declare function missingConfigFieldError(field: string, configPath: string): OmnifyError;
+/**
+ * Creates a schema parsing error.
+ */
+declare function schemaParseError(message: string, location: ErrorLocation, suggestion?: string): OmnifyError;
+/**
+ * Schema file not found error.
+ */
+declare function schemaNotFoundError(schemaPath: string): OmnifyError;
+/**
+ * Invalid YAML syntax error.
+ */
+declare function yamlSyntaxError(message: string, file: string, line?: number, column?: number): OmnifyError;
+/**
+ * Invalid JSON syntax error.
+ */
+declare function jsonSyntaxError(message: string, file: string, line?: number, column?: number): OmnifyError;
+/**
+ * Creates a schema validation error.
+ */
+declare function validationError(message: string, location: ErrorLocation, suggestion?: string): OmnifyError;
+/**
+ * Invalid property type error.
+ */
+declare function invalidPropertyTypeError(typeName: string, location: ErrorLocation, validTypes?: readonly string[]): OmnifyError;
+/**
+ * Missing required field error.
+ */
+declare function missingFieldError(field: string, location: ErrorLocation): OmnifyError;
+/**
+ * Invalid association target error.
+ */
+declare function invalidAssociationTargetError(target: string, location: ErrorLocation, availableSchemas?: readonly string[]): OmnifyError;
+/**
+ * Circular reference error.
+ */
+declare function circularReferenceError(path: readonly string[], location: ErrorLocation): OmnifyError;
+/**
+ * Duplicate schema name error.
+ */
+declare function duplicateSchemaError(name: string, location: ErrorLocation, existingLocation?: ErrorLocation): OmnifyError;
+/**
+ * Creates a plugin error.
+ */
+declare function pluginError(message: string, pluginName: string, cause?: Error): OmnifyError;
+/**
+ * Plugin not found error.
+ */
+declare function pluginNotFoundError(pluginName: string): OmnifyError;
+/**
+ * Plugin type conflict error.
+ */
+declare function pluginTypeConflictError(typeName: string, pluginA: string, pluginB: string): OmnifyError;
+/**
+ * Creates an Atlas error.
+ */
+declare function atlasError(message: string, cause?: Error): OmnifyError;
+/**
+ * Atlas CLI not found error.
+ */
+declare function atlasNotFoundError(): OmnifyError;
+/**
+ * Creates a generation error.
+ */
+declare function generationError(message: string, outputPath?: string, cause?: Error): OmnifyError;
+/**
+ * Output write error.
+ */
+declare function outputWriteError(outputPath: string, cause?: Error): OmnifyError;
+/**
+ * Creates an internal/unexpected error.
+ */
+declare function internalError(message: string, cause?: Error): OmnifyError;
+/**
+ * Not implemented error.
+ */
+declare function notImplementedError(feature: string): OmnifyError;
+
+/**
+ * @famgia/omnify-core - Schema Loader
+ *
+ * Load and parse YAML/JSON schema files into internal representation.
+ */
+
+/**
+ * Options for loading schemas.
+ */
+interface LoadSchemaOptions {
+    /** Base directory for calculating relative paths */
+    readonly baseDir?: string;
+}
+/**
+ * Options for loading a directory of schemas.
+ */
+interface LoadSchemasOptions {
+    /** File extensions to include (default: ['.yaml', '.yml']) */
+    readonly extensions?: readonly string[];
+    /** Whether to load recursively from subdirectories (default: true) */
+    readonly recursive?: boolean;
+}
+/**
+ * Converts a file name to a schema name (PascalCase).
+ *
+ * @example
+ * fileNameToSchemaName('user-profile.yaml') // 'UserProfile'
+ * fileNameToSchemaName('User.yaml') // 'User'
+ * fileNameToSchemaName('order_item.yml') // 'OrderItem'
+ */
+declare function fileNameToSchemaName(fileName: string): string;
+/**
+ * Parses YAML content into a SchemaDefinition.
+ *
+ * @param content - Raw YAML content
+ * @param filePath - File path for error reporting
+ * @returns Parsed schema definition
+ * @throws OmnifyError if YAML is invalid
+ */
+declare function parseYamlSchema(content: string, filePath: string): SchemaDefinition;
+/**
+ * Parses JSON content into a SchemaDefinition.
+ *
+ * @param content - Raw JSON content
+ * @param filePath - File path for error reporting
+ * @returns Parsed schema definition
+ * @throws OmnifyError if JSON is invalid
+ */
+declare function parseJsonSchema(content: string, filePath: string): SchemaDefinition;
+/**
+ * Loads a single schema file.
+ * Supports both YAML (.yaml, .yml) and JSON (.json) formats.
+ *
+ * @param filePath - Path to the schema file
+ * @param options - Loading options
+ * @returns Loaded schema with metadata
+ * @throws OmnifyError if file not found or invalid syntax
+ */
+declare function loadSchema(filePath: string, options?: LoadSchemaOptions): Promise<LoadedSchema>;
+/**
+ * Loads all schemas from a directory.
+ *
+ * @param directoryPath - Path to the schemas directory
+ * @param options - Loading options
+ * @returns Collection of loaded schemas indexed by name
+ * @throws OmnifyError if duplicate schema names or invalid files
+ */
+declare function loadSchemas(directoryPath: string, options?: LoadSchemasOptions): Promise<SchemaCollection>;
+
+/**
+ * @famgia/omnify-core - Validation Types
+ *
+ * Types for schema validation results.
+ */
+
+/**
+ * Validation result for a single schema.
+ */
+interface SchemaValidationResult {
+    /** Schema name */
+    readonly schemaName: string;
+    /** Whether validation passed */
+    readonly valid: boolean;
+    /** Validation errors (if any) */
+    readonly errors: readonly OmnifyError[];
+    /** Validation warnings (if any) */
+    readonly warnings: readonly OmnifyError[];
+}
+/**
+ * Validation result for a collection of schemas.
+ */
+interface ValidationResult {
+    /** Whether all schemas are valid */
+    readonly valid: boolean;
+    /** Total error count */
+    readonly errorCount: number;
+    /** Total warning count */
+    readonly warningCount: number;
+    /** Results per schema */
+    readonly schemas: readonly SchemaValidationResult[];
+    /** All errors across all schemas */
+    readonly errors: readonly OmnifyError[];
+    /** All warnings across all schemas */
+    readonly warnings: readonly OmnifyError[];
+}
+/**
+ * Options for schema validation.
+ */
+interface ValidationOptions {
+    /** Whether to treat warnings as errors */
+    readonly strict?: boolean;
+    /** Custom types registered by plugins */
+    readonly customTypes?: readonly string[];
+    /** Whether to validate associations (requires all schemas) */
+    readonly validateAssociations?: boolean;
+}
+
+/**
+ * @famgia/omnify-core - Schema Validator
+ *
+ * Validates schema definitions for correctness and consistency.
+ */
+
+/**
+ * Validates a property type.
+ */
+declare function validatePropertyType(propertyName: string, property: PropertyDefinition, filePath: string, customTypes?: readonly string[]): OmnifyError[];
+/**
+ * Validates all properties in a schema.
+ */
+declare function validateProperties(schema: SchemaDefinition, filePath: string, customTypes?: readonly string[]): OmnifyError[];
+/**
+ * Validates associations in a schema against available schemas.
+ */
+declare function validateAssociations(schema: LoadedSchema, allSchemas: SchemaCollection): OmnifyError[];
+/**
+ * Validates schema options.
+ */
+declare function validateOptions(schema: SchemaDefinition, filePath: string): OmnifyError[];
+/**
+ * Validates an enum schema.
+ */
+declare function validateEnumSchema(schema: SchemaDefinition, filePath: string): OmnifyError[];
+/**
+ * Validates a single schema.
+ */
+declare function validateSchema(schema: LoadedSchema, options?: ValidationOptions): SchemaValidationResult;
+/**
+ * Validates a collection of schemas.
+ */
+declare function validateSchemas(schemas: SchemaCollection, options?: ValidationOptions): ValidationResult;
+
+/**
+ * @famgia/omnify-core - Plugin Types
+ *
+ * Internal types for plugin management.
+ */
+
+/**
+ * Registered type with source plugin information.
+ */
+interface RegisteredType extends CustomTypeDefinition {
+    /** Plugin that provided this type */
+    readonly pluginName: string;
+    /** Plugin version */
+    readonly pluginVersion: string;
+}
+/**
+ * Plugin registry state.
+ */
+interface PluginRegistry {
+    /** Registered plugins */
+    readonly plugins: ReadonlyMap<string, OmnifyPlugin>;
+    /** Registered custom types */
+    readonly types: ReadonlyMap<string, RegisteredType>;
+}
+/**
+ * Plugin manager options.
+ */
+interface PluginManagerOptions {
+    /** Current working directory */
+    cwd?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Custom logger */
+    logger?: PluginLogger;
+}
+/**
+ * Result of plugin registration.
+ */
+interface PluginRegistrationResult {
+    /** Whether registration was successful */
+    success: boolean;
+    /** Registered types */
+    types: readonly RegisteredType[];
+    /** Any warnings during registration */
+    warnings: readonly string[];
+    /** Error if registration failed */
+    error?: string;
+}
+
+/**
+ * @famgia/omnify-core - Plugin Manager
+ *
+ * Manages plugin registration and type resolution.
+ */
+
+/**
+ * Plugin Manager class for managing plugin lifecycle.
+ */
+declare class PluginManager {
+    private readonly _plugins;
+    private readonly _types;
+    private readonly _cwd;
+    private readonly _verbose;
+    private readonly _logger;
+    constructor(options?: PluginManagerOptions);
+    /**
+     * Creates a plugin context for plugin setup.
+     */
+    private createContext;
+    /**
+     * Registers a single plugin.
+     */
+    register(plugin: OmnifyPlugin): Promise<PluginRegistrationResult>;
+    /**
+     * Registers multiple plugins.
+     */
+    registerAll(plugins: readonly OmnifyPlugin[]): Promise<void>;
+    /**
+     * Validates a type definition.
+     */
+    private validateTypeDefinition;
+    /**
+     * Unregisters a plugin and its types.
+     */
+    unregister(pluginName: string): Promise<void>;
+    /**
+     * Gets a registered type by name.
+     */
+    getType(typeName: string): RegisteredType | undefined;
+    /**
+     * Checks if a type is registered.
+     */
+    hasType(typeName: string): boolean;
+    /**
+     * Gets all registered types.
+     */
+    getAllTypes(): ReadonlyMap<string, RegisteredType>;
+    /**
+     * Gets all registered type names.
+     */
+    getTypeNames(): readonly string[];
+    /**
+     * Gets a registered plugin by name.
+     */
+    getPlugin(pluginName: string): OmnifyPlugin | undefined;
+    /**
+     * Gets all registered plugins.
+     */
+    getAllPlugins(): ReadonlyMap<string, OmnifyPlugin>;
+    /**
+     * Gets the current registry state.
+     */
+    getRegistry(): PluginRegistry;
+    /**
+     * Clears all registered plugins and types.
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Creates a new plugin manager instance.
+ */
+declare function createPluginManager(options?: PluginManagerOptions): PluginManager;
+
+/**
+ * @famgia/omnify-core - Compound Type Expander
+ *
+ * Expands compound types into multiple fields.
+ */
+
+/**
+ * Expanded property with original property name.
+ */
+interface ExpandedProperty {
+    /** Original property name */
+    originalName: string;
+    /** Expanded column name (originalName + suffix) */
+    expandedName: string;
+    /** The expanded field definition */
+    property: PropertyDefinition;
+    /** Whether this is from a compound type */
+    isCompound: boolean;
+    /** Source type name if from plugin */
+    sourceType?: string;
+}
+/**
+ * Expands a single property if it's a compound type.
+ */
+declare function expandProperty(propertyName: string, property: PropertyDefinition, registry: PluginRegistry): ExpandedProperty[];
+/**
+ * Expands all compound types in a schema's properties.
+ */
+declare function expandSchemaProperties(schema: LoadedSchema, registry: PluginRegistry): Map<string, ExpandedProperty[]>;
+/**
+ * Creates a new schema with compound types expanded.
+ */
+declare function expandSchema(schema: LoadedSchema, registry: PluginRegistry): LoadedSchema;
+/**
+ * Expands compound types in all schemas.
+ */
+declare function expandSchemas(schemas: SchemaCollection, registry: PluginRegistry): SchemaCollection;
+/**
+ * Gets the registered type info for a property type.
+ */
+declare function getTypeInfo(typeName: string, registry: PluginRegistry): RegisteredType | undefined;
+/**
+ * Checks if a type is a compound type.
+ */
+declare function isCompoundType(typeName: string, registry: PluginRegistry): boolean;
+/**
+ * Gets all custom type names from the registry.
+ */
+declare function getCustomTypeNames(registry: PluginRegistry): string[];
+
+/**
+ * @famgia/omnify-core - Programmatic API Types
+ */
+
+/**
+ * Migration file definition (matches @famgia/omnify-laravel).
+ */
+interface MigrationFile {
+    /** File path */
+    path: string;
+    /** Migration class name */
+    className: string;
+    /** Table name */
+    tableName: string;
+    /** File content */
+    content: string;
+    /** Operation type */
+    operation: 'create' | 'alter' | 'drop';
+}
+/**
+ * TypeScript file definition (matches @famgia/omnify-laravel).
+ */
+interface TypeScriptFile {
+    /** File path */
+    path: string;
+    /** File content */
+    content: string;
+}
+/**
+ * Lock file definition (matches @famgia/omnify-atlas).
+ */
+interface LockFileInfo {
+    /** Lock file version */
+    version: number;
+    /** Last updated timestamp */
+    updatedAt: string;
+    /** Schema hashes */
+    schemas: Record<string, string>;
+}
+/**
+ * Diff result definition (matches @famgia/omnify-atlas).
+ */
+interface DiffResultInfo {
+    /** Whether there are changes */
+    hasChanges: boolean;
+    /** SQL statements */
+    statements: string[];
+    /** Summary text */
+    summary: string;
+}
+/**
+ * Options for the Omnify programmatic API.
+ */
+interface OmnifyOptions {
+    /** Schema directory path */
+    schemaDir: string;
+    /** Configuration object or path to config file */
+    config?: Partial<OmnifyConfig> | string;
+    /** Plugins to register */
+    plugins?: OmnifyPlugin[];
+    /** Development database URL for Atlas */
+    devUrl?: string;
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Custom logger */
+    logger?: OmnifyLogger;
+}
+/**
+ * Logger interface for programmatic API.
+ */
+interface OmnifyLogger {
+    debug: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * Result of loading schemas.
+ */
+interface LoadResult {
+    /** Whether loading was successful */
+    success: boolean;
+    /** Loaded schemas */
+    schemas: SchemaCollection;
+    /** Validation errors if any */
+    errors: SchemaError[];
+    /** Validation warnings */
+    warnings: SchemaWarning[];
+}
+/**
+ * Schema error with location info.
+ */
+interface SchemaError {
+    /** File path */
+    file: string;
+    /** Line number if available */
+    line?: number;
+    /** Error message */
+    message: string;
+    /** Suggested fix */
+    suggestion?: string;
+}
+/**
+ * Schema warning.
+ */
+interface SchemaWarning {
+    /** File path */
+    file: string;
+    /** Warning message */
+    message: string;
+}
+/**
+ * Result of diff operation.
+ */
+interface DiffOperationResult {
+    /** Whether diff was successful */
+    success: boolean;
+    /** Whether there are changes */
+    hasChanges: boolean;
+    /** Parsed diff result */
+    diff: DiffResultInfo | null;
+    /** SQL statements */
+    sql: string[];
+    /** Human-readable summary */
+    summary: string;
+    /** Errors if any */
+    errors: SchemaError[];
+}
+/**
+ * Options for generation.
+ */
+interface GenerateOptions {
+    /** Output directory for Laravel migrations */
+    laravelOutput?: string;
+    /** Output directory for TypeScript types */
+    typescriptOutput?: string;
+    /** Whether to update the lock file */
+    updateLockFile?: boolean;
+    /** Whether to skip TypeScript generation */
+    skipTypeScript?: boolean;
+    /** Whether to skip Laravel generation */
+    skipLaravel?: boolean;
+    /** Dry run - don't write files */
+    dryRun?: boolean;
+}
+/**
+ * Result of generation operation.
+ */
+interface GenerateResult {
+    /** Whether generation was successful */
+    success: boolean;
+    /** Generated Laravel migration files */
+    migrations: MigrationFile[];
+    /** Generated TypeScript files */
+    typescript: TypeScriptFile[];
+    /** Updated lock file */
+    lockFile: LockFileInfo | null;
+    /** Errors if any */
+    errors: SchemaError[];
+    /** Files that would be written (in dry run) or were written */
+    files: GeneratedFile[];
+}
+/**
+ * Generated file info.
+ */
+interface GeneratedFile {
+    /** File path */
+    path: string;
+    /** File content */
+    content: string;
+    /** File type */
+    type: 'migration' | 'typescript' | 'lock';
+}
+/**
+ * Schema metadata for introspection.
+ */
+interface SchemaMetadata {
+    /** Schema name */
+    name: string;
+    /** Display name */
+    displayName?: string;
+    /** Group name */
+    group?: string;
+    /** Schema kind */
+    kind: 'entity' | 'enum';
+    /** File path */
+    filePath: string;
+    /** Property names */
+    propertyNames: string[];
+    /** Association names */
+    associationNames: string[];
+    /** Has timestamps */
+    hasTimestamps: boolean;
+    /** Has soft delete */
+    hasSoftDelete: boolean;
+    /** Primary key type */
+    primaryKeyType: string;
+}
+/**
+ * Property metadata.
+ */
+interface PropertyMetadata {
+    /** Property name */
+    name: string;
+    /** Property type */
+    type: string;
+    /** Is nullable */
+    nullable: boolean;
+    /** Is unique */
+    unique: boolean;
+    /** Has default value */
+    hasDefault: boolean;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Is from plugin */
+    isPluginType: boolean;
+    /** Plugin name if from plugin */
+    pluginName?: string;
+}
+/**
+ * Association metadata.
+ */
+interface AssociationMetadata {
+    /** Association name */
+    name: string;
+    /** Relation type */
+    relation: 'OneToOne' | 'OneToMany' | 'ManyToOne' | 'ManyToMany';
+    /** Target schema */
+    target: string;
+    /** Inverse side */
+    inversedBy?: string;
+    /** Owning side */
+    mappedBy?: string;
+    /** On delete action */
+    onDelete?: string;
+    /** On update action */
+    onUpdate?: string;
+}
+/**
+ * Full schema introspection result.
+ */
+interface SchemaIntrospection {
+    /** Schema metadata */
+    metadata: SchemaMetadata;
+    /** Properties */
+    properties: PropertyMetadata[];
+    /** Associations */
+    associations: AssociationMetadata[];
+    /** Raw schema */
+    schema: LoadedSchema;
+}
+
+/**
+ * @famgia/omnify-core - Omnify Programmatic API
+ *
+ * Main entry point for using omnify-schema programmatically.
+ */
+
+/**
+ * Main Omnify API class for programmatic usage.
+ *
+ * @example
+ * ```typescript
+ * import { Omnify } from '@famgia/omnify-core';
+ *
+ * const omnify = new Omnify({
+ *   schemaDir: './schemas',
+ *   plugins: [japanTypesPlugin],
+ * });
+ *
+ * // Load and validate schemas
+ * const { schemas, errors } = await omnify.load();
+ *
+ * // Get schema metadata
+ * const users = omnify.getSchema('User');
+ *
+ * // Introspect schema
+ * const introspection = omnify.introspect('User');
+ * ```
+ */
+declare class Omnify {
+    private readonly options;
+    private readonly logger;
+    private readonly pluginManager;
+    private schemas;
+    private loaded;
+    constructor(options: OmnifyOptions);
+    /**
+     * Registers plugins with the plugin manager.
+     */
+    registerPlugins(plugins: OmnifyPlugin[]): Promise<void>;
+    /**
+     * Loads and validates schemas from the configured directory.
+     */
+    load(): Promise<LoadResult>;
+    /**
+     * Gets loaded schemas. Throws if not loaded.
+     */
+    getSchemas(): SchemaCollection;
+    /**
+     * Gets a single schema by name.
+     */
+    getSchema(name: string): SchemaIntrospection | undefined;
+    /**
+     * Gets all schema names.
+     */
+    getSchemaNames(): string[];
+    /**
+     * Gets entity schemas (non-enum).
+     */
+    getEntitySchemas(): SchemaIntrospection[];
+    /**
+     * Gets enum schemas.
+     */
+    getEnumSchemas(): SchemaIntrospection[];
+    /**
+     * Gets schemas by group.
+     */
+    getSchemasByGroup(group: string): SchemaIntrospection[];
+    /**
+     * Gets all unique group names.
+     */
+    getGroups(): string[];
+    /**
+     * Introspects a specific schema.
+     */
+    introspect(name: string): SchemaIntrospection | undefined;
+    /**
+     * Introspects all schemas.
+     */
+    introspectAll(): Map<string, SchemaIntrospection>;
+    /**
+     * Finds schemas that reference a target schema.
+     */
+    findReferencingSchemas(targetName: string): SchemaIntrospection[];
+    /**
+     * Finds schemas referenced by a source schema.
+     */
+    findReferencedSchemas(sourceName: string): SchemaIntrospection[];
+    /**
+     * Checks if schemas have circular references.
+     */
+    hasCircularReferences(): boolean;
+    /**
+     * Gets topological order of schemas (dependencies first).
+     */
+    getTopologicalOrder(): string[];
+    /**
+     * Gets the plugin registry.
+     */
+    getPluginRegistry(): PluginRegistry;
+    /**
+     * Checks if a type is registered (from plugin).
+     */
+    hasType(typeName: string): boolean;
+    /**
+     * Gets custom type names from all registered plugins.
+     */
+    getCustomTypeNames(): string[];
+}
+/**
+ * Creates an Omnify instance.
+ *
+ * @example
+ * ```typescript
+ * const omnify = createOmnify({
+ *   schemaDir: './schemas',
+ * });
+ *
+ * const { schemas } = await omnify.load();
+ * ```
+ */
+declare function createOmnify(options: OmnifyOptions): Omnify;
+
+/**
+ * @famgia/omnify-core - Schema Metadata Access
+ *
+ * Utilities for accessing schema metadata programmatically.
+ */
+
+/**
+ * Extracts metadata from a loaded schema.
+ */
+declare function getSchemaMetadata(schema: LoadedSchema): SchemaMetadata;
+/**
+ * Extracts property metadata.
+ */
+declare function getPropertyMetadata(name: string, property: PropertyDefinition, registry?: PluginRegistry): PropertyMetadata;
+/**
+ * Extracts association metadata.
+ */
+declare function getAssociationMetadata(name: string, association: AssociationDefinition): AssociationMetadata;
+/**
+ * Full schema introspection.
+ */
+declare function introspectSchema(schema: LoadedSchema, registry?: PluginRegistry): SchemaIntrospection;
+/**
+ * Introspects all schemas in a collection.
+ */
+declare function introspectSchemas(schemas: SchemaCollection, registry?: PluginRegistry): Map<string, SchemaIntrospection>;
+/**
+ * Gets all schema names from a collection.
+ */
+declare function getSchemaNames(schemas: SchemaCollection): string[];
+/**
+ * Gets schemas by kind.
+ */
+declare function getSchemasByKind(schemas: SchemaCollection, kind: 'entity' | 'enum'): LoadedSchema[];
+/**
+ * Gets entity schemas (non-enum).
+ */
+declare function getEntitySchemas(schemas: SchemaCollection): LoadedSchema[];
+/**
+ * Gets enum schemas.
+ */
+declare function getEnumSchemas(schemas: SchemaCollection): LoadedSchema[];
+/**
+ * Gets schemas by group.
+ */
+declare function getSchemasByGroup(schemas: SchemaCollection, group: string): LoadedSchema[];
+/**
+ * Gets all unique group names.
+ */
+declare function getGroups(schemas: SchemaCollection): string[];
+/**
+ * Finds schemas that reference a target schema.
+ */
+declare function findReferencingSchemas(schemas: SchemaCollection, targetName: string): LoadedSchema[];
+/**
+ * Finds schemas referenced by a source schema.
+ */
+declare function findReferencedSchemas(schemas: SchemaCollection, sourceName: string): LoadedSchema[];
+/**
+ * Gets the relationship graph as adjacency list.
+ */
+declare function getRelationshipGraph(schemas: SchemaCollection): Map<string, string[]>;
+/**
+ * Checks if schemas form a valid DAG (no circular references).
+ */
+declare function hasCircularReferences(schemas: SchemaCollection): boolean;
+/**
+ * Gets topological sort order for schemas (dependencies first).
+ */
+declare function getTopologicalOrder(schemas: SchemaCollection): string[];
+
+export { type AssociationMetadata, type DiffOperationResult, type ExpandedProperty, type FormatOptions, type GenerateOptions, type GenerateResult, type GeneratedFile, type LoadResult, type LoadSchemaOptions, type LoadSchemasOptions, Omnify, OmnifyError, type OmnifyLogger, type OmnifyOptions, PluginManager, type PluginManagerOptions, type PluginRegistrationResult, type PluginRegistry, type PropertyMetadata, type RegisteredType, type SchemaError, type SchemaIntrospection, type SchemaMetadata, type SchemaValidationResult, type SchemaWarning, type ValidationOptions, type ValidationResult, atlasError, atlasNotFoundError, circularReferenceError, configError, configNotFoundError, createOmnify, createPluginManager, duplicateSchemaError, expandProperty, expandSchema, expandSchemaProperties, expandSchemas, fileNameToSchemaName, findReferencedSchemas, findReferencingSchemas, formatError, formatErrorPlain, formatErrorSummary, generationError, getAssociationMetadata, getCustomTypeNames, getEntitySchemas, getEnumSchemas, getExitCode, getGroups, getPropertyMetadata, getRelationshipGraph, getSchemaMetadata, getSchemaNames, getSchemasByGroup, getSchemasByKind, getTopologicalOrder, getTypeInfo, hasCircularReferences, internalError, introspectSchema, introspectSchemas, invalidAssociationTargetError, invalidConfigError, invalidPropertyTypeError, isCompoundType, jsonSyntaxError, loadSchema, loadSchemas, missingConfigFieldError, missingFieldError, notImplementedError, outputWriteError, parseJsonSchema, parseYamlSchema, pluginError, pluginNotFoundError, pluginTypeConflictError, schemaNotFoundError, schemaParseError, validateAssociations, validateEnumSchema, validateOptions, validateProperties, validatePropertyType, validateSchema, validateSchemas, validationError, yamlSyntaxError };