@db3.ai/app 0.1.0-beta.1

package/dist/db/fields/UrlField.d.ts

@@ -0,0 +1,30 @@
+import { BasicFieldState, FieldContext, FieldError } from '../FieldType.js';
+import type { ValidationRule } from '../../validation/index.js';
+import { TextField, type TextFieldConfig } from './TextField.js';
+/**
+ * Configuration for URL fields.
+ */
+export interface UrlFieldConfig extends TextFieldConfig {
+    /** Allowed URL protocols. Defaults to HTTP and HTTPS. */
+    allowedProtocols?: string[];
+    /** Whether the hostname must contain a dot. Defaults to true. */
+    requirePublicHostname?: boolean;
+    /** Protocol to prepend when users omit one. Defaults to `https://`. */
+    defaultProtocol?: 'http://' | 'https://';
+}
+/**
+ * URL field with request-friendly normalization.
+ *
+ * It accepts values with or without a protocol, trims whitespace, normalises via
+ * the platform URL parser, and returns `null` for values that cannot be saved as
+ * public URLs.
+ */
+export declare class UrlField extends TextField {
+    readonly config: UrlFieldConfig;
+    constructor(config?: UrlFieldConfig);
+    protected parse(input: unknown): string | null;
+    protected defaultFormComponent(): string;
+    getValidationRules(ctx?: FieldContext): ValidationRule[];
+    protected collectErrors(state: BasicFieldState<string | null>): Promise<FieldError[]>;
+    private normalizeUrl;
+}

package/dist/db/fields/UrlField.js

@@ -0,0 +1,61 @@
+import { TextField, } from './TextField.js';
+/**
+ * URL field with request-friendly normalization.
+ *
+ * It accepts values with or without a protocol, trims whitespace, normalises via
+ * the platform URL parser, and returns `null` for values that cannot be saved as
+ * public URLs.
+ */
+export class UrlField extends TextField {
+    constructor(config = {}) {
+        super({
+            maxLength: 2000,
+            ...config,
+        });
+    }
+    parse(input) {
+        const value = super.parse(input);
+        if (!value)
+            return null;
+        return this.normalizeUrl(value);
+    }
+    defaultFormComponent() {
+        return 'DomUrlInput';
+    }
+    getValidationRules(ctx) {
+        return [
+            ...super.getValidationRules(ctx),
+            'url',
+        ];
+    }
+    async collectErrors(state) {
+        const errors = await super.collectErrors(state);
+        const value = state.value;
+        if (value && !this.normalizeUrl(value)) {
+            errors.push({
+                field: this.fieldName,
+                message: `${this.fieldName} must be a valid URL`,
+                code: 'url',
+                value,
+            });
+        }
+        return errors;
+    }
+    normalizeUrl(value) {
+        const candidate = /^[a-z][a-z\d+.-]*:\/\//i.test(value)
+            ? value
+            : `${this.config.defaultProtocol ?? 'https://'}${value}`;
+        try {
+            const url = new URL(candidate);
+            const allowedProtocols = this.config.allowedProtocols ?? ['http:', 'https:'];
+            if (!allowedProtocols.includes(url.protocol))
+                return null;
+            if ((this.config.requirePublicHostname ?? true) && !url.hostname.includes('.'))
+                return null;
+            return url.toString();
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/db/fields/VectorField.d.ts

@@ -0,0 +1,64 @@
+import type { ValidationRule } from '../../validation/index.js';
+import { type BasicFieldState, type DbSchemaPart, type FieldConfig, type FieldContext, type FieldError, type FieldRenderOptions, FieldType } from '../FieldType.js';
+import type { DatabaseValueOptions } from '../dialects/index.js';
+type VectorDbValue = Uint8Array | string | number[] | null;
+/**
+ * Configuration for native database vectors such as embeddings.
+ */
+export interface VectorFieldConfig extends FieldConfig {
+    /** Expected number of vector dimensions. Leave unset to use the database default. */
+    dimensions?: number;
+    /** Whether to create a database-native vector index. Defaults to true for required vectors. */
+    index?: boolean;
+}
+/**
+ * Stores an embedding/vector as a native database VECTOR column.
+ */
+export declare class VectorField extends FieldType<number[] | null, unknown, number[] | null, unknown, BasicFieldState<number[] | null>> {
+    readonly config: VectorFieldConfig;
+    /**
+     * Creates a native vector field and validates schema-level options.
+     */
+    constructor(config?: VectorFieldConfig);
+    /**
+     * Parses JSON text, decoded arrays, or binary vector input into app memory.
+     */
+    protected parse(input: unknown): number[] | null;
+    /**
+     * Hydrates binary vectors, vector text, or already-decoded arrays.
+     */
+    protected fromDbValue(input: VectorDbValue): number[] | null;
+    /**
+     * Converts app-memory vectors into the active dialect's native vector value.
+     */
+    protected toDbValue(input: number[] | null, options?: DatabaseValueOptions): unknown;
+    /**
+     * Uses a JSON editor for manual vector editing in generated forms.
+     */
+    protected defaultFormComponent(): string;
+    /**
+     * Disables default scalar search filtering for vector fields.
+     */
+    protected defaultSearchFilterComponent(): string | null;
+    /**
+     * Adds dimension metadata to generated vector form props.
+     */
+    protected defaultFormComponentProps(options: FieldRenderOptions): Record<string, unknown>;
+    /**
+     * Publishes request validation rules for array-shaped vector input.
+     */
+    getValidationRules(ctx?: FieldContext): ValidationRule[];
+    /**
+     * Describes the native VECTOR column used by this field.
+     */
+    getDbSchema(ctx?: FieldContext): DbSchemaPart;
+    /**
+     * Reports non-array, non-number, and dimension mismatch errors.
+     */
+    protected collectErrors(state: BasicFieldState<number[] | null>): Promise<FieldError[]>;
+    /**
+     * Treats an empty vector as empty for required validation.
+     */
+    protected isEmpty(value: unknown): boolean;
+}
+export {};

package/dist/db/fields/VectorField.js

@@ -0,0 +1,180 @@
+import { FieldType, } from '../FieldType.js';
+import { resolveDatabaseDialect } from '../dialects/index.js';
+/**
+ * Stores an embedding/vector as a native database VECTOR column.
+ */
+export class VectorField extends FieldType {
+    /**
+     * Creates a native vector field and validates schema-level options.
+     */
+    constructor(config = {}) {
+        const resolvedConfig = {
+            selectedByDefault: false,
+            index: config.index ?? Boolean(config.required),
+            ...config,
+        };
+        super(resolvedConfig);
+        validateVectorConfig(resolvedConfig, resolveDatabaseDialect().vectorMaxDimensions);
+    }
+    /**
+     * Parses JSON text, decoded arrays, or binary vector input into app memory.
+     */
+    parse(input) {
+        if (input === null || input === undefined || input === '') {
+            return null;
+        }
+        return resolveDatabaseDialect().vectorFromDbValue(input);
+    }
+    /**
+     * Hydrates binary vectors, vector text, or already-decoded arrays.
+     */
+    fromDbValue(input) {
+        return this.parse(input);
+    }
+    /**
+     * Converts app-memory vectors into the active dialect's native vector value.
+     */
+    toDbValue(input, options) {
+        if (input === null || input === undefined) {
+            return null;
+        }
+        const dialect = options?.dialect ?? resolveDatabaseDialect();
+        return dialect.vectorToDbValue(input, options?.db);
+    }
+    /**
+     * Uses a JSON editor for manual vector editing in generated forms.
+     */
+    defaultFormComponent() {
+        return 'DomJsonInput';
+    }
+    /**
+     * Disables default scalar search filtering for vector fields.
+     */
+    defaultSearchFilterComponent() {
+        return null;
+    }
+    /**
+     * Adds dimension metadata to generated vector form props.
+     */
+    defaultFormComponentProps(options) {
+        const props = super.defaultFormComponentProps(options);
+        if (this.config.dimensions !== undefined) {
+            props.dimensions = this.config.dimensions;
+        }
+        return props;
+    }
+    /**
+     * Publishes request validation rules for array-shaped vector input.
+     */
+    getValidationRules(ctx) {
+        const rules = super.getValidationRules(ctx);
+        rules.push('array');
+        return rules;
+    }
+    /**
+     * Describes the native VECTOR column used by this field.
+     */
+    getDbSchema(ctx) {
+        return this.withContext(ctx, () => {
+            const dialect = this.schemaDialect();
+            validateVectorConfig(this.config, dialect.vectorMaxDimensions);
+            return this.completeDbSchema({
+                columns: [
+                    {
+                        name: this.column,
+                        type: dialect.vectorColumnType(this.config.dimensions),
+                        nullable: !this.config.required,
+                    },
+                ],
+                indexes: vectorSchemaIndexes(this.column, this.config, dialect),
+            }, ctx);
+        });
+    }
+    /**
+     * Reports non-array, non-number, and dimension mismatch errors.
+     */
+    async collectErrors(state) {
+        const errors = await super.collectErrors(state);
+        const value = state.value;
+        if (this.isEmpty(value)) {
+            return errors;
+        }
+        if (!Array.isArray(value)) {
+            errors.push({
+                field: this.fieldName,
+                message: `${this.fieldName} must be an array of numbers`,
+                code: 'array',
+                value,
+            });
+            return errors;
+        }
+        const invalidIndex = value.findIndex(item => (typeof item !== 'number' || !Number.isFinite(item)));
+        if (invalidIndex !== -1) {
+            errors.push({
+                field: this.fieldName,
+                message: `${this.fieldName} must contain only finite numbers`,
+                code: 'numberArray',
+                value,
+                details: {
+                    invalidIndex,
+                },
+            });
+        }
+        if (this.config.dimensions !== undefined
+            && value.length !== this.config.dimensions) {
+            errors.push({
+                field: this.fieldName,
+                message: `${this.fieldName} must contain ${this.config.dimensions} numbers`,
+                code: 'dimensions',
+                value,
+                details: {
+                    dimensions: this.config.dimensions,
+                    actual: value.length,
+                },
+            });
+        }
+        return errors;
+    }
+    /**
+     * Treats an empty vector as empty for required validation.
+     */
+    isEmpty(value) {
+        return super.isEmpty(value) || (Array.isArray(value) && value.length === 0);
+    }
+}
+/**
+ * Validates configuration that native VECTOR columns cannot support.
+ */
+function validateVectorConfig(config, maxDimensions) {
+    if (config.dimensions !== undefined
+        && (!Number.isInteger(config.dimensions)
+            || config.dimensions <= 0
+            || config.dimensions > maxDimensions)) {
+        throw new Error(`VectorField dimensions must be an integer between 1 and ${maxDimensions}.`);
+    }
+    if (config.primary || config.unique || (config.indexes?.length ?? 0) > 0) {
+        throw new Error('VECTOR columns cannot be primary, unique, or custom normal indexed keys.');
+    }
+    if (config.index && !config.required) {
+        throw new Error('VECTOR indexes require required: true because MariaDB vector indexes cannot include nullable columns.');
+    }
+}
+/**
+ * Builds the native vector index metadata for dialects that support it.
+ *
+ * @param column - Database column that stores the vector.
+ * @param config - Vector field configuration.
+ * @param dialect - Active database dialect.
+ * @returns Vector index schema metadata, or undefined when disabled/unsupported.
+ */
+function vectorSchemaIndexes(column, config, dialect) {
+    if (!config.index || !dialect.supportsVectorIndexes)
+        return undefined;
+    return [
+        {
+            type: 'vector',
+            columns: [column],
+            name: config.indexName,
+        },
+    ];
+}

package/dist/db/fields/createField.d.ts

@@ -0,0 +1,2 @@
+import { FieldInput, FieldType } from '../FieldType.js';
+export declare function createField<TField extends FieldType<any, any, any, any, any>>(input: FieldInput<TField>): TField;

package/dist/db/fields/createField.js

@@ -0,0 +1,13 @@
+import { FieldType, } from '../FieldType.js';
+export function createField(input) {
+    if (typeof input === 'function') {
+        return new input();
+    }
+    if (input instanceof FieldType) {
+        return input.clone();
+    }
+    if (input && typeof input === 'object' && 'type' in input) {
+        return new input.type(input.config);
+    }
+    throw new Error('Invalid field definition.');
+}

package/dist/db/fields/field.d.ts

@@ -0,0 +1,36 @@
+import type { ActiveRecord, ActiveRecordClass } from '../ActiveRecord.js';
+import { EncryptedJsonField, type EncryptedJsonFieldConfig } from './EncryptedJsonField.js';
+import { BooleanField, type BooleanFieldConfig, BigIncrementsField, CharUuidField, type CharUuidFieldConfig, ChoiceStringField, type ChoiceStringFieldConfig, DecimalField, type DecimalFieldConfig, EmailField, type EmailFieldConfig, JsonField, type JsonFieldConfig, JsonStringField, type JsonStringFieldConfig, IntegerField, type IntegerFieldConfig, LinkField, type LinkFieldConfig, PasswordField, type PasswordFieldConfig, StringListField, type StringListFieldConfig, StringField, type StringFieldConfig, TextField, type TextFieldConfig, TimestampField, type TimestampFieldConfig, UlidField, type UlidFieldConfig, UrlField, type UrlFieldConfig, VectorField, type VectorFieldConfig } from './index.js';
+export { createField } from './createField.js';
+export interface FieldBuilder {
+    bigIncrements(config?: IntegerFieldConfig): BigIncrementsField;
+    boolean(config?: BooleanFieldConfig): BooleanField;
+    charUuid(config?: CharUuidFieldConfig): CharUuidField;
+    choice(config: ChoiceStringFieldConfig): ChoiceStringField;
+    decimal(config?: DecimalFieldConfig): DecimalField;
+    email(config?: EmailFieldConfig): EmailField;
+    /** Creates authenticated encrypted JSON stored in a non-queryable long text column. */
+    encryptedJson<TValue>(config?: EncryptedJsonFieldConfig): EncryptedJsonField<TValue>;
+    /** Creates a permissive JSON field for arbitrary JSON-compatible values. */
+    json<TValue>(config?: JsonFieldConfig): JsonField<TValue | null>;
+    /** Creates a backwards-compatible JSON field that serializes values for storage. */
+    jsonString<TValue>(config?: JsonStringFieldConfig): JsonStringField<TValue>;
+    /** Creates a JSON field serializes into a `text` column. */
+    jsonText<TValue>(config?: JsonStringFieldConfig): JsonStringField<TValue>;
+    /** Creates a JSON field serializes into a `longtext` column. */
+    jsonLongText<TValue>(config?: JsonStringFieldConfig): JsonStringField<TValue>;
+    integer(config?: IntegerFieldConfig): IntegerField;
+    link<TRecord extends ActiveRecord>(target: () => ActiveRecordClass<TRecord>, config?: Omit<LinkFieldConfig<TRecord>, 'target'>): LinkField<TRecord>;
+    /** Creates a JSON-backed list of normalized strings. */
+    stringList(config?: StringListFieldConfig): StringListField;
+    password(config: PasswordFieldConfig): PasswordField;
+    string(config?: StringFieldConfig): StringField;
+    text(config?: TextFieldConfig): TextField;
+    longText(config?: TextFieldConfig): TextField;
+    timestamp(config?: TimestampFieldConfig): TimestampField;
+    ulid(config?: UlidFieldConfig): UlidField;
+    url(config?: UrlFieldConfig): UrlField;
+    /** Creates a native numeric vector field for embeddings. */
+    vector(config?: VectorFieldConfig): VectorField;
+}
+export declare const field: FieldBuilder;

package/dist/db/fields/field.js

@@ -0,0 +1,101 @@
+import { EncryptedJsonField } from './EncryptedJsonField.js';
+import { BooleanField, BigIncrementsField, CharUuidField, ChoiceStringField, DecimalField, EmailField, JsonField, JsonStringField, IntegerField, LinkField, PasswordField, StringListField, StringField, TextField, TimestampField, UlidField, UrlField, VectorField, } from './index.js';
+export { createField } from './createField.js';
+export const field = {
+    bigIncrements(config = {}) {
+        return new BigIncrementsField(config);
+    },
+    boolean(config = {}) {
+        return new BooleanField(config);
+    },
+    charUuid(config = {}) {
+        return new CharUuidField(config);
+    },
+    choice(config) {
+        return new ChoiceStringField(config);
+    },
+    decimal(config = {}) {
+        return new DecimalField(config);
+    },
+    email(config = {}) {
+        return new EmailField(config);
+    },
+    /**
+     * Creates authenticated encrypted JSON stored in a non-queryable long text column.
+     */
+    encryptedJson(config = {}) {
+        return new EncryptedJsonField(config);
+    },
+    /**
+     * Creates a permissive JSON field for arbitrary JSON-compatible values.
+     */
+    json(config = {}) {
+        return new JsonField(config);
+    },
+    /**
+     * Creates a backwards-compatible JSON field that serializes values for storage.
+     */
+    jsonString(config = {}) {
+        return new JsonStringField(config);
+    },
+    /**
+     * Creates a JSON field serialized into a `text` column.
+     */
+    jsonText(config = {}) {
+        return new JsonStringField({
+            ...config,
+            dbType: 'text',
+        });
+    },
+    /**
+     * Creates a JSON field serialized into a `longtext` column.
+     */
+    jsonLongText(config = {}) {
+        return new JsonStringField({
+            ...config,
+            dbType: 'longtext',
+        });
+    },
+    integer(config = {}) {
+        return new IntegerField(config);
+    },
+    link(target, config = {}) {
+        return new LinkField({
+            ...config,
+            target,
+        });
+    },
+    /**
+     * Creates a JSON-backed list of normalized strings.
+     */
+    stringList(config = {}) {
+        return new StringListField(config);
+    },
+    password(config) {
+        return new PasswordField(config);
+    },
+    string(config = {}) {
+        return new StringField(config);
+    },
+    text(config = {}) {
+        return new TextField(config);
+    },
+    longText(config = {}) {
+        return field.text(config);
+    },
+    timestamp(config = {}) {
+        return new TimestampField(config);
+    },
+    ulid(config = {}) {
+        return new UlidField(config);
+    },
+    url(config = {}) {
+        return new UrlField(config);
+    },
+    /**
+     * Creates a native numeric vector field for embeddings.
+     */
+    vector(config = {}) {
+        return new VectorField(config);
+    },
+};

package/dist/db/fields/index.d.ts

@@ -0,0 +1,18 @@
+export { BooleanField, type BooleanFieldConfig, } from './BooleanField.js';
+export { CharUuidField, type CharUuidFieldConfig, } from './CharUuidField.js';
+export { ChoiceStringField, type ChoiceStringFieldConfig, } from './ChoiceStringField.js';
+export { DecimalField, type DecimalFieldConfig, } from './DecimalField.js';
+export { EmailField, type EmailFieldConfig, } from './EmailField.js';
+export { EncryptedJsonField, EncryptedJsonFieldError, type EncryptedJsonFieldConfig, } from './EncryptedJsonField.js';
+export { JsonField, type JsonFieldConfig, } from './JsonField.js';
+export { JsonStringField, type JsonStringFieldConfig, type JsonStringFieldDbType, } from './JsonStringField.js';
+export { BigIncrementsField, IntegerField, type IntegerFieldConfig, } from './IntegerField.js';
+export { EntityRef, LinkField, type LinkFieldConfig, } from './LinkField.js';
+export { StringListField, type StringListFieldConfig, } from './StringListField.js';
+export { PasswordField, type PasswordFieldConfig, } from './PasswordField.js';
+export { StringField, type StringFieldConfig, } from './StringField.js';
+export { TextField, type TextFieldConfig, } from './TextField.js';
+export { TimestampField, type TimestampFieldConfig, } from './TimestampField.js';
+export { VectorField, type VectorFieldConfig, } from './VectorField.js';
+export { UlidField, type UlidFieldConfig, } from './UlidField.js';
+export { UrlField, type UrlFieldConfig, } from './UrlField.js';

package/dist/db/fields/index.js

@@ -0,0 +1,18 @@
+export { BooleanField, } from './BooleanField.js';
+export { CharUuidField, } from './CharUuidField.js';
+export { ChoiceStringField, } from './ChoiceStringField.js';
+export { DecimalField, } from './DecimalField.js';
+export { EmailField, } from './EmailField.js';
+export { EncryptedJsonField, EncryptedJsonFieldError, } from './EncryptedJsonField.js';
+export { JsonField, } from './JsonField.js';
+export { JsonStringField, } from './JsonStringField.js';
+export { BigIncrementsField, IntegerField, } from './IntegerField.js';
+export { EntityRef, LinkField, } from './LinkField.js';
+export { StringListField, } from './StringListField.js';
+export { PasswordField, } from './PasswordField.js';
+export { StringField, } from './StringField.js';
+export { TextField, } from './TextField.js';
+export { TimestampField, } from './TimestampField.js';
+export { VectorField, } from './VectorField.js';
+export { UlidField, } from './UlidField.js';
+export { UrlField, } from './UrlField.js';

package/dist/db/fields/resolveFields.d.ts

@@ -0,0 +1,17 @@
+import type { FieldInputMap, FieldMap, ModelMetadata } from '../FieldType.js';
+import { type FieldBuilder } from './field.js';
+export interface FieldFactoryModel {
+    fields(field: FieldBuilder): FieldInputMap;
+}
+/**
+ * Resolves and returns a model's static field definitions as a FieldMap.
+ *
+ * - Invokes the model's `fields` static method with the framework field helper.
+ * - Accepts a model class or object implementing `FieldFactoryModel` & `ModelMetadata`.
+ * - Each field definition is normalized to a FieldType instance and bound to the model and its logical field name.
+ * - Results are cached per-model for efficiency, using a WeakMap to avoid memory leaks.
+ *
+ * @param Model  A model class/object implementing field factory and metadata interfaces.
+ * @returns      Resolved fields as a map: { [fieldName]: FieldType }
+ */
+export declare function resolveModelFields(Model: FieldFactoryModel & ModelMetadata): FieldMap;

package/dist/db/fields/resolveFields.js

@@ -0,0 +1,38 @@
+import { FieldType } from '../FieldType.js';
+import { field, } from './field.js';
+const resolvedFieldsByModel = new WeakMap();
+/**
+ * Resolves and returns a model's static field definitions as a FieldMap.
+ *
+ * - Invokes the model's `fields` static method with the framework field helper.
+ * - Accepts a model class or object implementing `FieldFactoryModel` & `ModelMetadata`.
+ * - Each field definition is normalized to a FieldType instance and bound to the model and its logical field name.
+ * - Results are cached per-model for efficiency, using a WeakMap to avoid memory leaks.
+ *
+ * @param Model  A model class/object implementing field factory and metadata interfaces.
+ * @returns      Resolved fields as a map: { [fieldName]: FieldType }
+ */
+export function resolveModelFields(Model) {
+    const cached = resolvedFieldsByModel.get(Model);
+    if (cached) {
+        return cached;
+    }
+    const fields = {};
+    for (const [fieldName, fieldInput] of Object.entries(Model.fields(field))) {
+        fields[fieldName] = resolveFieldInput(fieldInput).bindToModel(Model, fieldName);
+    }
+    resolvedFieldsByModel.set(Model, fields);
+    return fields;
+}
+function resolveFieldInput(input) {
+    if (typeof input === 'function') {
+        return new input();
+    }
+    if (input instanceof FieldType) {
+        return input.clone();
+    }
+    if (input && typeof input === 'object' && 'type' in input) {
+        return new input.type(input.config);
+    }
+    throw new Error('Invalid field definition.');
+}

package/dist/db/index.d.ts

@@ -0,0 +1,13 @@
+export * from './ActiveRecord.js';
+export * from './ActiveProjection.js';
+export * from './ActiveQueryBuilder.js';
+export * from './Database.js';
+export * from './contracts/index.js';
+export * from './FieldType.js';
+export * from './dialects/index.js';
+export * from './errors.js';
+export * from './fields/index.js';
+export * from './migrations/index.js';
+export * from './SoftDeletes.js';
+export * from './sqlErrors.js';
+export * from './queryMonitor.js';

package/dist/db/index.js

@@ -0,0 +1,13 @@
+export * from './ActiveRecord.js';
+export * from './ActiveProjection.js';
+export * from './ActiveQueryBuilder.js';
+export * from './Database.js';
+export * from './contracts/index.js';
+export * from './FieldType.js';
+export * from './dialects/index.js';
+export * from './errors.js';
+export * from './fields/index.js';
+export * from './migrations/index.js';
+export * from './SoftDeletes.js';
+export * from './sqlErrors.js';
+export * from './queryMonitor.js';

package/dist/db/migrations/DatabaseMigrationManager.d.ts

@@ -0,0 +1,57 @@
+import type { DatabaseCheckResult, DatabaseMigrationManagerOptions, DatabaseMigrationStatus, DatabaseSyncResult, MakeMigrationOptions, MakeMigrationResult, MigrateOptions, MigrateResult } from './contracts/index.js';
+/**
+ * Reusable application-configured model migration service.
+ *
+ * CLI commands, development HTTP actions, and deployment scripts should call
+ * this service rather than duplicating model collection or Knex execution.
+ */
+export declare class DatabaseMigrationManager {
+    #private;
+    /**
+     * Creates a migration manager with app-owned models, paths, and ledger name.
+     *
+     * @param options - Database connection, model registry, and absolute source paths.
+     */
+    constructor(options: DatabaseMigrationManagerOptions);
+    /**
+     * Returns model, snapshot, live database, and Knex migration status without
+     * creating the Knex migration ledger.
+     *
+     * @returns Structured status suitable for CLI or development UI rendering.
+     */
+    status(): Promise<DatabaseMigrationStatus>;
+    /**
+     * Checks the live model-owned database subset against current models.
+     *
+     * Extra columns and tables are ignored to preserve additive blue/green
+     * compatibility, while missing or incompatible requirements are reported.
+     *
+     * @returns Structured database compatibility result.
+     */
+    check(): Promise<DatabaseCheckResult>;
+    /**
+     * Generates a frozen migration and advances the committed snapshot when
+     * current models contain only supported changes.
+     *
+     * @param options - Optional human-readable migration name.
+     * @returns Generation result including blocked changes or written file path.
+     */
+    makeMigration(options?: MakeMigrationOptions): Promise<MakeMigrationResult>;
+    /**
+     * Applies pending committed migrations through Knex's ledger and lock.
+     *
+     * @param options - Optional matching-database baseline policy.
+     * @returns Applied migration names, batch, and optional baselined filenames.
+     */
+    migrate(options?: MigrateOptions): Promise<MigrateResult>;
+    /**
+     * Runs the development convenience flow under one generation lock.
+     *
+     * A blocked model diff returns immediately without applying migrations. A
+     * successful flow always finishes with a live database compatibility check.
+     *
+     * @param options - Optional human-readable generated migration name.
+     * @returns Structured make, migrate, and check results.
+     */
+    sync(options?: MakeMigrationOptions): Promise<DatabaseSyncResult>;
+}