/**
 * Field builders for entity definitions
 *
 * Each method returns a new immutable object (functional programming pattern).
 * Chain methods to build field configurations fluently.
 *
 * @module fields
 */
export interface Validation {
    type: string;
    value?: unknown;
}
export interface FieldConfig {
    type: 'text' | 'number' | 'boolean' | 'date' | 'computed' | 'enum';
    required: boolean;
    unique: boolean;
    default?: unknown;
    label?: string;
    validations: Validation[];
    /** For computed fields: the return type */
    returnType?: 'text' | 'number' | 'boolean' | 'date';
    /** For computed fields: source fields used in computation */
    sourceFields?: string[];
    /** For computed fields: the computation expression */
    expression?: string;
    /** For enum fields: the allowed values */
    enumValues?: readonly string[];
    /** For enum fields: custom enum type name (optional) */
    enumName?: string;
}
export interface BaseFieldBuilder<T> {
    /** @internal - Do not use directly. Use the fluent methods instead. */
    readonly _config: FieldConfig;
    required(): T;
    optional(): T;
    unique(): T;
    default(value: unknown): T;
    label(value: string): T;
}
export interface TextFieldBuilder extends BaseFieldBuilder<TextFieldBuilder> {
    min(value: number): TextFieldBuilder;
    max(value: number): TextFieldBuilder;
    length(value: number): TextFieldBuilder;
    email(): TextFieldBuilder;
    url(): TextFieldBuilder;
    regex(pattern: RegExp): TextFieldBuilder;
    oneOf<V extends string>(values: readonly V[]): TextFieldBuilder;
    trim(): TextFieldBuilder;
    lowercase(): TextFieldBuilder;
    uppercase(): TextFieldBuilder;
}
export interface NumberFieldBuilder extends BaseFieldBuilder<NumberFieldBuilder> {
    min(value: number): NumberFieldBuilder;
    max(value: number): NumberFieldBuilder;
    integer(): NumberFieldBuilder;
    positive(): NumberFieldBuilder;
}
export interface BooleanFieldBuilder extends BaseFieldBuilder<BooleanFieldBuilder> {
    default(value: boolean): BooleanFieldBuilder;
}
export interface DateFieldBuilder extends BaseFieldBuilder<DateFieldBuilder> {
    default(value: 'now' | Date): DateFieldBuilder;
}
export interface EnumFieldBuilder<T extends readonly string[]> extends BaseFieldBuilder<EnumFieldBuilder<T>> {
    /** Set the default value (must be one of the enum values) */
    default(value: NoInfer<T[number]>): EnumFieldBuilder<T>;
}
export interface ComputedFieldBuilder {
    readonly _config: FieldConfig;
    /** Set a label for the field */
    label(value: string): ComputedFieldBuilder;
}
export type FieldBuilder = TextFieldBuilder | NumberFieldBuilder | BooleanFieldBuilder | DateFieldBuilder | EnumFieldBuilder<readonly string[]> | ComputedFieldBuilder;
/**
 * Create a text field builder
 *
 * @returns TextFieldBuilder with chainable methods
 *
 * @example
 * ```typescript
 * text()
 *   .required()
 *   .unique()
 *   .email()
 *   .min(5).max(255)
 *   .trim()
 *   .lowercase()
 * ```
 */
export declare function text(): TextFieldBuilder;
/**
 * Create a number field builder
 *
 * @returns NumberFieldBuilder with chainable methods
 *
 * @example
 * ```typescript
 * number()
 *   .required()
 *   .min(0).max(100)
 *   .integer()
 *   .positive()
 * ```
 */
export declare function number(): NumberFieldBuilder;
/**
 * Create a boolean field builder
 *
 * @returns BooleanFieldBuilder with chainable methods
 *
 * @example
 * ```typescript
 * boolean().default(false)
 * ```
 */
export declare function boolean(): BooleanFieldBuilder;
/**
 * Create a date field builder
 *
 * @returns DateFieldBuilder with chainable methods
 *
 * @example
 * ```typescript
 * date().default('now')
 * date().required()
 * ```
 */
export declare function date(): DateFieldBuilder;
/**
 * Create an enum field builder with type-safe values
 *
 * Enum fields create native database enum types (PostgreSQL) or
 * CHECK constraints (SQLite/MySQL) and generate proper Zod enums.
 *
 * @param values - Allowed string values (automatically inferred as readonly)
 * @returns EnumFieldBuilder with chainable methods
 *
 * @example
 * ```typescript
 * // Basic enum (no 'as const' needed!)
 * status: enumField('draft', 'published', 'archived')
 *
 * // With default
 * status: enumField('draft', 'published', 'archived')
 *   .required()
 *   .default('draft')
 *
 * // Order status
 * orderStatus: enumField('pending', 'processing', 'shipped', 'delivered')
 *   .required()
 *   .default('pending')
 * ```
 */
export declare function enumField<const T extends readonly string[]>(...values: T): EnumFieldBuilder<T>;
/**
 * Computed field configuration
 */
export interface ComputedOptions {
    /** The return type of the computed field */
    type: 'text' | 'number' | 'boolean' | 'date';
    /** Source fields used in the computation */
    from: string[];
    /**
     * The computation expression. Use field names as variables.
     *
     * For text concatenation: `"${firstName} ${lastName}"`
     * For math: `"price * quantity"`
     * For conditionals: `"stock > 0 ? 'In Stock' : 'Out of Stock'"`
     */
    get: string;
}
/**
 * Create a computed/virtual field
 *
 * Computed fields are derived from other fields at runtime.
 * They are included in API responses but excluded from create/update inputs.
 * They are NOT stored in the database.
 *
 * @param options - Configuration for the computed field
 * @returns ComputedFieldBuilder
 *
 * @example
 * ```typescript
 * // Full name from first + last
 * fullName: computed({
 *   type: 'text',
 *   from: ['firstName', 'lastName'],
 *   get: '`${firstName} ${lastName}`'
 * })
 *
 * // Total price
 * totalPrice: computed({
 *   type: 'number',
 *   from: ['price', 'quantity'],
 *   get: 'price * quantity'
 * })
 *
 * // Stock status
 * inStock: computed({
 *   type: 'boolean',
 *   from: ['quantity'],
 *   get: 'quantity > 0'
 * })
 * ```
 */
export declare function computed(options: ComputedOptions): ComputedFieldBuilder;
//# sourceMappingURL=fields.d.ts.map