import { ObjectId } from 'mongodb';

interface BooleanFieldProps extends BaseField {
    default?: boolean;
}
interface BooleanField extends BooleanFieldProps {
    type: 'boolean';
}

interface DateFieldProps extends BaseField {
    default?: Date;
}
interface DateField extends DateFieldProps {
    type: "date";
}

interface NumberFieldProps extends BaseField {
    default?: number;
    min?: number;
    max?: number;
}
interface NumberField extends NumberFieldProps {
    type: "number";
}

interface StringFieldProps extends BaseField {
    default?: string;
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    enum?: string[];
}
interface StringField extends StringFieldProps {
    type: "string";
}

type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'objectId' | 'object';
type BaseField = {
    required?: boolean;
    optional?: boolean;
    unique?: boolean;
    transform?: (value: string) => unknown;
};
interface ObjectFieldProps<T extends Record<string, MonkoField>> extends BaseField {
    schema: T;
}
interface ObjectField<T extends Record<string, MonkoField>> extends ObjectFieldProps<T> {
    type: 'object';
}
type MonkoField = StringField | NumberField | BooleanField | DateField | ObjectIdField | ObjectField<Record<string, MonkoField>>;
/**
 * Infers the actual TypeScript type (
 *   string, number, boolean, Date, ObjectId
 * ) from a given MonkoField.
 */
type InferMonkoFieldType<F> = F extends StringField ? string : F extends NumberField ? number : F extends BooleanField ? boolean : F extends DateField ? Date : F extends ObjectIdField ? ObjectId : F extends ObjectField<infer S> ? {
    [K in keyof S]: InferMonkoFieldType<S[K]>;
} : F extends [infer U] ? InferMonkoFieldType<U>[] : never;

interface ObjectIdFieldProps extends BaseField {
    default?: string;
    ref?: string;
}
interface ObjectIdField extends ObjectIdFieldProps {
    type: "objectId";
}

/**
 * Defines the structure for a Monko schema configuration.
 * This is the input type for the `defineSchema` function.
 */
interface SchemaDefinition {
    /** The name of the model/schema (e.g., 'User'). */
    name: string;
    /** The name of the database this schema belongs to. */
    db: string;
    /** The name of the collection in the database. */
    collection: string;
    /** An object defining the fields of the schema. Keys are field names. */
    fields: Record<string, MonkoField>;
}
/**
 * Defines a Monko schema.
 * This function will take a schema definition, validate it,
 * and return a processed schema object that can be used by the ORM.
 *
 * @param definition The schema definition object.
 * @returns A processed Monko schema.
 */
declare function defineSchema<const T extends SchemaDefinition>(schema: T): T;

export { type BaseField as B, type DateField as D, type FieldType as F, type InferMonkoFieldType as I, type MonkoField as M, type NumberField as N, type ObjectFieldProps as O, type SchemaDefinition as S, type ObjectField as a, type BooleanField as b, type DateFieldProps as c, defineSchema as d, type NumberFieldProps as e, type ObjectIdField as f, type ObjectIdFieldProps as g, type StringField as h, type StringFieldProps as i, type BooleanFieldProps as j };