import { FieldOptions, FieldOutput, FieldValidateInput, TailorFieldType, TailorToTs } from "../../types/field.types.mjs";
import { InferredAttributes } from "../../../runtime/types.mjs";
import { InferFieldsOutput, IsUnion, TypeLevelError, UnionToIntersection, output } from "../../../types/helpers.mjs";
import { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeDefaultedDBFields, ExcludeHookedDBFields, ExcludeNestedDBFields, Hook, IndexDef, RelationType, SerialConfig, TailorDBField as TailorDBField$1, TailorDBType as TailorDBType$1, TypeFeatures, TypeHook, TypeValidateFn, UpdateHookFn } from "./types.mjs";
import { AllowedValues, AllowedValuesOutput } from "../../types/field.mjs";
import { FieldParseArgs } from "../../../runtime/field-parse.mjs";
import { PluginConfigs, PluginFieldExtensions } from "../../../plugin/types.mjs";
import { TailorTypeGqlPermission, TailorTypePermission } from "./permission.mjs";
import { StandardSchemaV1 } from "@standard-schema/spec";
//#region src/configure/services/tailordb/schema.d.ts
type AnyBuilderMethod = any;
export type TailorAnyDBField = Omit<TailorDBField$1<AnyBuilderMethod, AnyBuilderMethod>, "fields"> & {
  readonly fields: Record<string, AnyBuilderMethod>;
  _metadata: DBFieldMetadata;
  parse: AnyBuilderMethod;
  readonly typeName: TypeLevelError<string>;
  description: AnyBuilderMethod;
  relation: AnyBuilderMethod;
  index: AnyBuilderMethod;
  unique: AnyBuilderMethod;
  vector: AnyBuilderMethod;
  default: AnyBuilderMethod;
  hooks: AnyBuilderMethod;
  validate: AnyBuilderMethod;
  serial: AnyBuilderMethod;
  clone: AnyBuilderMethod;
};
export type TailorAnyDBType = TailorDBType<any, any, any>;
type IsAny<T> = 0 extends 1 & T ? true : false;
type DBFieldTypeNameMethod<Defined extends DefinedDBFieldMetadata> = IsAny<Defined> extends true ? TypeLevelError<string> : TypeLevelError<"typeName cannot be used on TailorDB fields">;
type WithDBFieldDescription<Defined> = Defined & {
  description: true;
};
type WithDBFieldRelation<Defined, S extends RelationType | RelationSelfConfig> = S extends "oneToOne" | "1-1" ? Defined & {
  unique: true;
  index: true;
  relation: true;
} : S extends {
  type: "oneToOne" | "1-1";
} ? Defined & {
  unique: true;
  index: true;
  relation: true;
} : Defined & {
  index: true;
  relation: true;
};
type WithDBFieldIndex<Defined> = Defined & {
  index: true;
};
type WithDBFieldUnique<Defined> = Defined & {
  unique: true;
  index: true;
};
type WithDBFieldVector<Defined> = Defined & {
  vector: true;
};
type WithDBFieldHooks<Defined, H> = Defined & {
  hooks: {
    create: H extends {
      create: unknown;
    } ? true : false;
    update: H extends {
      update: unknown;
    } ? true : false;
  };
  serial: false;
};
type WithDBFieldDefault<Defined> = Defined & {
  default: true;
};
type WithDBFieldValidate<Defined> = Defined & {
  validate: true;
};
type WithDBFieldSerial<Defined> = Defined & {
  serial: true;
  hooks: {
    create: false;
    update: false;
  };
};
type WithDBFieldCloneOptions<Defined extends DefinedDBFieldMetadata, NewOpt extends FieldOptions> = IsAny<Defined> extends true ? Defined : Omit<Defined, "array"> & {
  array: NewOpt extends {
    array: true;
  } ? true : NewOpt extends {
    array: false;
  } ? false : Defined["array"];
};
type NonNullableDBFieldOutput<Output> = Exclude<Output, null>;
type DBFieldScalarOutput<Output> = NonNullableDBFieldOutput<Output> extends (infer Item)[] ? Item : NonNullableDBFieldOutput<Output>;
type DBFieldCloneArrayOutput<Output, NewOpt extends FieldOptions> = NewOpt extends {
  array: true;
} ? DBFieldScalarOutput<Output>[] : NewOpt extends {
  array: false;
} ? DBFieldScalarOutput<Output> : NonNullableDBFieldOutput<Output>;
type DBFieldCloneOutput<Output, NewOpt extends FieldOptions> = NewOpt extends {
  optional: true;
} ? DBFieldCloneArrayOutput<Output, NewOpt> | null : NewOpt extends {
  optional: false;
} ? DBFieldCloneArrayOutput<Output, NewOpt> : null extends Output ? DBFieldCloneArrayOutput<Output, NewOpt> | null : DBFieldCloneArrayOutput<Output, NewOpt>;
type DBFieldCloneOptions<Defined extends DefinedDBFieldMetadata> = Omit<FieldOptions, "array"> & {
  array?: Defined extends {
    validate: unknown;
  } ? Defined["array"] : boolean;
};
type InvalidValidatedArrayCloneKeys<Fields extends Record<string, TailorAnyDBField>, K extends keyof Fields, Opt extends FieldOptions> = Opt extends {
  array: infer ArrayOption;
} ? { [P in K]: Fields[P] extends TailorDBField<infer Defined, infer _Output> ? Defined extends {
  validate: unknown;
} ? ArrayOption extends Defined["array"] ? never : P : never : never; }[K] : never;
type DBFieldsCloneOptionsGuard<Fields extends Record<string, TailorAnyDBField>, K extends keyof Fields, Opt extends FieldOptions> = [InvalidValidatedArrayCloneKeys<Fields, K, Opt>] extends [never] ? unknown : TypeLevelError<"array cannot be changed on fields with custom validation">;
type DefinedDBTypeMetadata = {
  hooks?: true;
  validate?: true;
  features?: true;
  indexes?: true;
  files?: true;
  permission?: true;
  gqlPermission?: true;
  description?: true;
};
type WithDBTypeMetadata<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata> = Defined & Record<Key, true>;
type DBTypeDuplicateInputGuard<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata, Input, Message extends string> = IsAny<Defined> extends true ? Input : Defined extends Record<Key, unknown> ? TypeLevelError<Message> : Input;
type DBTypeDuplicateRestGuard<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata, Input extends unknown[], Message extends string> = IsAny<Defined> extends true ? Input : Defined extends Record<Key, unknown> ? [TypeLevelError<Message>, ...TypeLevelError<Message>[]] : Input;
type FileKeyConflictError<Fields extends Record<string, TailorAnyDBField>, User extends object> = Partial<Record<keyof output<TailorDBType<Fields, User>> & string, TypeLevelError<"file keys cannot use existing field names">>>;
type PluginFieldExtensionFor<Fields extends Record<string, TailorAnyDBField>, Id extends string, IdConfig> = Id extends keyof PluginFieldExtensions<keyof Fields & string, IdConfig> ? PluginFieldExtensions<keyof Fields & string, IdConfig>[Id] : Record<never, never>;
type PluginFieldExtensionsUnion<Fields extends Record<string, TailorAnyDBField>, Config extends Record<string, unknown>> = { [Id in keyof Config & string]: PluginFieldExtensionFor<Fields, Id, Config[Id]>; }[keyof Config & string];
type AllExtensionKeys<Ext> = Ext extends unknown ? keyof Ext : never;
type PluginFieldExtensionShapeError<Fields extends Record<string, TailorAnyDBField>, Config extends Record<string, unknown>, Id extends string> = PluginFieldExtensionFor<Fields, Id, Config[Id & keyof Config]> extends Record<string, TailorAnyDBField> ? false : true;
type PluginFieldConflict<Fields extends Record<string, TailorAnyDBField>, Config extends Record<string, unknown>, Id extends string, FileKeys extends string> = [AllExtensionKeys<PluginFieldExtensionFor<Fields, Id, Config[Id & keyof Config]>> & (keyof Fields | FileKeys | AllExtensionKeys<PluginFieldExtensionsUnion<Fields, Omit<Config, Id>>>)] extends [never] ? false : true;
type PluginConfigExcessProps<Fields extends Record<string, TailorAnyDBField>, Config extends Record<string, unknown>, Id extends string> = Record<Exclude<keyof Config[Id & keyof Config], keyof PluginConfigs<keyof Fields & string>[Id & keyof PluginConfigs<keyof Fields & string>]>, never>;
type PluginExtendedFields<Fields extends Record<string, TailorAnyDBField>, Config extends Record<string, unknown>> = IsAny<Fields> extends true ? Fields // For `Config = {}`, PluginFieldExtensionsUnion is `never`, and
 : Fields & UnionToIntersection<PluginFieldExtensionsUnion<Fields, Config>>;
type PluginConfigGuard<Fields extends Record<string, TailorAnyDBField>, Config extends Record<string, unknown>, FileKeys extends string> = IsAny<Fields> extends true ? unknown : { [K in keyof Config]: K extends keyof PluginConfigs<keyof Fields & string> ? IsUnion<Config[K]> extends true ? TypeLevelError<"plugin config must be a single object literal, not a union — assign the config to a variable first if it comes from a conditional expression"> : PluginFieldExtensionShapeError<Fields, Config, K & string> extends true ? TypeLevelError<"PluginFieldExtensions entry must be a Record<string, TailorAnyDBField>"> : PluginFieldConflict<Fields, Config, K & string, FileKeys> extends true ? TypeLevelError<"plugin field extension conflicts with an existing field, a file key declared via .files(), or another plugin's field"> : PluginConfigs<keyof Fields & string>[K] & PluginConfigExcessProps<Fields, Config, K & string> : TypeLevelError<"unknown plugin id">; };
type DBFieldDescriptionFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = (description: string) => TailorDBField<WithDBFieldDescription<Defined>, Output, Nested>;
type DBFieldRelationFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = {
  <S extends RelationType, T extends TailorAnyDBType>(config: RelationConfig<S, T>): TailorDBField<WithDBFieldRelation<Defined, S>, Output, Nested>;
  <S extends RelationSelfConfig>(config: S): TailorDBField<WithDBFieldRelation<Defined, S>, Output, Nested>;
};
type DBFieldIndexFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = () => TailorDBField<WithDBFieldIndex<Defined>, Output, Nested>;
type DBFieldUniqueFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = () => TailorDBField<WithDBFieldUnique<Defined>, Output, Nested>;
type DBFieldVectorFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = () => TailorDBField<WithDBFieldVector<Defined>, Output, Nested>;
type DBFieldHooksFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = <const H extends Hook<Output, Defined extends {
  default: true;
} ? Output | null | undefined : Output>>(hooks: H) => TailorDBField<WithDBFieldHooks<Defined, H>, Output, Nested>;
type DBFieldValidateFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = (...validate: FieldValidateInput<Output>[]) => TailorDBField<WithDBFieldValidate<Defined>, Output, Nested>;
type DBFieldSerialFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = (config: SerialConfig<Defined["type"] & ("integer" | "string")>) => TailorDBField<WithDBFieldSerial<Defined>, Output, Nested>;
type DBFieldDescriptionMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldDescriptionFn<Defined, Output, Nested> : Defined extends {
  description: unknown;
} ? TypeLevelError<".description() has already been set"> : DBFieldDescriptionFn<Defined, Output, Nested>;
type DBFieldRelationMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldRelationFn<Defined, Output, Nested> : Defined extends {
  relation: unknown;
} ? TypeLevelError<".relation() has already been set"> : DBFieldRelationFn<Defined, Output, Nested>;
type DBFieldArrayCheck<A extends boolean, Ok, Msg extends string> = A extends true ? TypeLevelError<Msg> : Ok;
type DBFieldIndexMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldIndexFn<Defined, Output, Nested> : Defined extends {
  index: unknown;
} ? TypeLevelError<".index() has already been set"> : DBFieldArrayCheck<Defined["array"], DBFieldIndexFn<Defined, Output, Nested>, "index cannot be set on array fields">;
type DBFieldUniqueMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldUniqueFn<Defined, Output, Nested> : Defined extends {
  unique: unknown;
} ? TypeLevelError<".unique() has already been set"> : DBFieldArrayCheck<Defined["array"], DBFieldUniqueFn<Defined, Output, Nested>, "unique cannot be set on array fields">;
type DBFieldVectorMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldVectorFn<Defined, Output, Nested> : Defined extends {
  vector: unknown;
} ? TypeLevelError<".vector() has already been set"> : Defined extends {
  type: "string";
  array: false;
} ? DBFieldVectorFn<Defined, Output, Nested> : TypeLevelError<"vector can only be set on non-array string fields">;
type DBFieldHooksMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldHooksFn<Defined, Output, Nested> : Defined extends {
  serial: true;
  hooks: {
    create: false;
    update: false;
  };
} ? TypeLevelError<"hooks cannot be set after serial"> : Defined extends {
  hooks: unknown;
} ? TypeLevelError<".hooks() has already been set"> : Defined extends {
  type: "nested";
} ? TypeLevelError<"hooks cannot be set on nested type fields"> : DBFieldHooksFn<Defined, Output, Nested>;
type DBFieldValidateMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldValidateFn<Defined, Output, Nested> : Defined extends {
  validate: unknown;
} ? TypeLevelError<".validate() has already been set"> : DBFieldValidateFn<Defined, Output, Nested>;
type DBFieldSerialMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldSerialFn<Defined, Output, Nested> : Defined extends {
  serial: true;
} ? TypeLevelError<".serial() has already been set"> : Defined extends {
  serial: false;
} ? TypeLevelError<"serial cannot be set after hooks"> : IsAny<Output> extends true ? Defined extends {
  type: "integer" | "string";
  array: false;
} ? DBFieldSerialFn<Defined, Output, Nested> : TypeLevelError<"serial can only be set on non-array integer or string fields"> : null extends Output ? TypeLevelError<"serial can only be set on non-array integer or string fields"> : Defined extends {
  type: "integer" | "string";
  array: false;
} ? DBFieldSerialFn<Defined, Output, Nested> : TypeLevelError<"serial can only be set on non-array integer or string fields">;
type DBFieldDefaultFn<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = (value: Output extends null ? NonNullable<Output> : Output) => TailorDBField<WithDBFieldDefault<Defined>, Output, Nested>;
type DBFieldDefaultMethod<Defined extends DefinedDBFieldMetadata, Output, Nested extends Record<string, TailorAnyDBField>> = IsAny<Defined> extends true ? DBFieldDefaultFn<Defined, Output, Nested> : Defined extends {
  default: unknown;
} ? TypeLevelError<".default() has already been set"> : Defined extends {
  type: "nested";
} ? TypeLevelError<"default cannot be set on nested type fields"> : Defined extends {
  serial: true;
} ? TypeLevelError<"default cannot be set on serial fields"> : null extends Output ? TypeLevelError<"default cannot be set on optional fields"> : DBFieldDefaultFn<Defined, Output, Nested>;
/**
 * Full TailorDBField interface with builder methods.
 * Extends the minimal structural interface from types/ with fluent API methods.
 */
export interface TailorDBField<Defined extends DefinedDBFieldMetadata = DefinedDBFieldMetadata, Output = any, Nested extends Record<string, TailorAnyDBField> = Record<string, TailorAnyDBField>> extends Omit<TailorDBField$1<Defined, Output, Nested>, "fields"> {
  readonly fields: Nested;
  _metadata: DBFieldMetadata;
  /**
   * Parse and validate a value against this field's validation rules
   */
  parse(args: FieldParseArgs): StandardSchemaV1.Result<Output>;
  /**
   * typeName is not available on TailorDB fields.
   * Use typeName on pipeline fields (t.enum / t.object) instead.
   */
  typeName: DBFieldTypeNameMethod<Defined>;
  /**
   * Set a description for the field
   */
  description: DBFieldDescriptionMethod<Defined, Output, Nested>;
  /**
   * Define a relation to another table.
   */
  relation: DBFieldRelationMethod<Defined, Output, Nested>;
  /**
   * Add an index to the field
   */
  index: DBFieldIndexMethod<Defined, Output, Nested>;
  /**
   * Make the field unique (also adds an index)
   */
  unique: DBFieldUniqueMethod<Defined, Output, Nested>;
  /**
   * Enable vector search on the field (string type only)
   */
  vector: DBFieldVectorMethod<Defined, Output, Nested>;
  /**
   * Set a default value for the field on create. When the field is required,
   * this makes it optional in the Create input — the default fills in when
   * no value (or a nullish hook result) is provided.
   *
   * For datetime/date/time fields, pass `"now"` to use the operation timestamp.
   */
  default: DBFieldDefaultMethod<Defined, Output, Nested>;
  /**
   * Add hooks for create/update operations on this field.
   */
  hooks: DBFieldHooksMethod<Defined, Output, Nested>;
  /**
   * Add validation functions to the field.
   *
   * Validators receive `{ value, data, user }` and run after hooks and
   * built-in type validation; they are skipped when built-in validation
   * fails. For array fields, `value` is the complete array.
   */
  validate: DBFieldValidateMethod<Defined, Output, Nested>;
  /**
   * Configure serial/auto-increment behavior
   */
  serial: DBFieldSerialMethod<Defined, Output, Nested>;
  /**
   * Clone the field with optional overrides for field options.
   * The `array` option cannot change on fields with custom validation.
   */
  clone<const NewOpt extends DBFieldCloneOptions<Defined>>(options?: NewOpt): TailorDBField<WithDBFieldCloneOptions<Defined, NewOpt>, DBFieldCloneOutput<Output, NewOpt>, Nested>;
}
/**
 * Full TailorDBType interface with builder methods.
 * Extends the minimal structural interface from types/ with fluent API methods.
 */
export interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes, Defined extends DefinedDBTypeMetadata = any, FileKeys extends string = never> extends TailorDBType$1<Fields, User> {
  _description?: string;
  hooks(hook: DBTypeDuplicateInputGuard<Defined, "hooks", TypeHook<Fields>, ".hooks() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "hooks">, FileKeys>;
  validate(fn: DBTypeDuplicateInputGuard<Defined, "validate", TypeValidateFn<Fields>, ".validate() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "validate">, FileKeys>;
  features(features: DBTypeDuplicateInputGuard<Defined, "features", Omit<TypeFeatures, "pluralForm">, ".features() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "features">, FileKeys>;
  indexes(...indexes: DBTypeDuplicateRestGuard<Defined, "indexes", IndexDef<TailorDBType<Fields, User, Defined, FileKeys>>[], ".indexes() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "indexes">, FileKeys>;
  files<const F extends string>(files: DBTypeDuplicateInputGuard<Defined, "files", Record<F, string> & FileKeyConflictError<Fields, User>, ".files() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "files">, FileKeys | F>;
  permission<U extends object = User, P extends TailorTypePermission<U, output<TailorDBType<Fields, User, Defined>>> = TailorTypePermission<U, output<TailorDBType<Fields, User, Defined>>>>(permission: DBTypeDuplicateInputGuard<Defined, "permission", P, ".permission() has already been set">): TailorDBType<Fields, U, WithDBTypeMetadata<Defined, "permission">, FileKeys>;
  gqlPermission<U extends object = User, P extends TailorTypeGqlPermission<U> = TailorTypeGqlPermission<U>>(permission: DBTypeDuplicateInputGuard<Defined, "gqlPermission", P, ".gqlPermission() has already been set">): TailorDBType<Fields, U, WithDBTypeMetadata<Defined, "gqlPermission">, FileKeys>;
  description(description: DBTypeDuplicateInputGuard<Defined, "description", string, ".description() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "description">, FileKeys>;
  pickFields<K extends keyof Fields>(keys: K[]): Pick<Fields, K>;
  pickFields<K extends keyof Fields, const Opt extends FieldOptions>(keys: K[], options: Opt & DBFieldsCloneOptionsGuard<Fields, K, Opt>): { [P in K]: Fields[P] extends TailorDBField<infer D, infer O> ? TailorDBField<WithDBFieldCloneOptions<D, Opt>, DBFieldCloneOutput<O, Opt>> : never; };
  omitFields<K extends keyof Fields>(keys: K[]): Omit<Fields, K>;
  plugin<const Config extends Record<string, unknown>>(config: Config & PluginConfigGuard<Fields, Config, FileKeys>): TailorDBType<PluginExtendedFields<Fields, Config>, User, Defined, FileKeys>;
}
export type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes, Defined extends DefinedDBTypeMetadata = any, FileKeys extends string = never> = TailorDBType<Fields, User, Defined, FileKeys>;
interface RelationConfig<S extends RelationType, T extends TailorDBType> {
  type: S;
  toward: {
    table: T;
    as?: string;
    key?: keyof T["fields"] & string;
    type?: never;
  } | {
    /**
     * @deprecated since 2.6.0 — use `table` instead. codemod: v3/relation-toward-table
     */
    type: T;
    as?: string;
    key?: keyof T["fields"] & string;
    table?: never;
  };
  backward?: string;
}
type RelationSelfConfig = {
  type: RelationType;
  toward: {
    table: "self";
    as?: string;
    key?: string;
    type?: never;
  } | {
    /**
     * @deprecated since 2.6.0 — use `table` instead. codemod: v3/relation-toward-table
     */
    type: "self";
    as?: string;
    key?: string;
    table?: never;
  };
  backward?: string;
};
type DBFieldDefined<T extends TailorFieldType, Opt extends FieldOptions> = {
  type: T;
  array: Opt extends {
    array: true;
  } ? true : false;
};
type DBFieldOutput<T extends TailorFieldType, Opt extends FieldOptions, OutputBase = TailorToTs[T]> = FieldOutput<OutputBase, Opt>;
type TailorDBFieldInstance<T extends TailorFieldType, Opt extends FieldOptions, OutputBase = TailorToTs[T]> = TailorDBField<DBFieldDefined<T, Opt>, DBFieldOutput<T, Opt, OutputBase>>;
/**
 * Create a UUID field.
 * @param options - Field configuration options
 * @returns A UUID field
 * @example db.uuid()
 * @example db.uuid({ optional: true })
 */
declare function uuid<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"uuid", Opt, string>;
/**
 * Create a string field.
 * @param options - Field configuration options
 * @returns A string field
 * @example db.string()
 * @example db.string({ optional: true })
 */
declare function string<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"string", Opt, string>;
/**
 * Create a boolean field.
 * Note: The method name is `bool` but creates a `boolean` type field.
 * @param options - Field configuration options
 * @returns A boolean field
 * @example db.bool()
 * @example db.bool({ optional: true })
 */
declare function bool<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"boolean", Opt, boolean>;
/**
 * Create an integer field.
 * @param options - Field configuration options
 * @returns An integer field
 * @example db.int()
 * @example db.int({ optional: true })
 */
declare function int<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"integer", Opt, number>;
/**
 * Create a float (decimal number) field.
 * @param options - Field configuration options
 * @returns A float field
 * @example db.float()
 * @example db.float({ optional: true })
 */
declare function float<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"float", Opt, number>;
interface DecimalFieldOptions extends FieldOptions {
  scale?: number;
}
/**
 * Create a decimal field (stored as string for precision).
 * @param options - Field configuration options including optional scale (0-12)
 * @returns A decimal field
 * @example db.decimal()
 * @example db.decimal({ scale: 2 })
 * @example db.decimal({ scale: 2, optional: true })
 */
declare function decimal<const Opt extends DecimalFieldOptions>(options?: Opt): TailorDBFieldInstance<"decimal", Opt, string>;
/**
 * Create a date field (date only, no time component).
 * Format: "yyyy-MM-dd"
 * @param options - Field configuration options
 * @returns A date field
 * @example db.date()
 */
declare function date<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"date", Opt, string>;
/**
 * Create a datetime field (date and time).
 * Format: ISO 8601, such as "yyyy-MM-ddTHH:mm:ssZ" or "yyyy-MM-ddTHH:mm:ss+09:00"
 * @param options - Field configuration options
 * @returns A datetime field
 * @example db.datetime()
 */
declare function datetime<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"datetime", Opt, string | Date>;
/**
 * Create a time field (time only, no date component).
 * Format: "HH:mm"
 * @param options - Field configuration options
 * @returns A time field
 * @example db.time()
 */
declare function time<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"time", Opt, string>;
/**
 * Create an enum field with at least one allowed string value.
 * @param values - Array of allowed string values, or array of `{ value, description }` objects
 * @param options - Field configuration options
 * @returns An enum field
 * @example db.enum(["active", "inactive", "suspended"])
 * @example db.enum(["small", "medium", "large"], { optional: true })
 */
declare function _enum<const V extends AllowedValues, const Opt extends FieldOptions>(values: V, options?: Opt): TailorDBField<{
  type: "enum";
  array: Opt extends {
    array: true;
  } ? true : false;
}, FieldOutput<AllowedValuesOutput<V>, Opt>>;
/**
 * Create a nested object field with sub-fields.
 * @param fields - Record of nested field definitions
 * @param options - Field configuration options
 * @returns A nested object field
 * @example db.object({ street: db.string(), city: db.string(), zip: db.string() })
 * @example db.object({ name: db.string() }, { optional: true })
 */
declare function object<const F extends Record<string, TailorAnyDBField> & ExcludeNestedDBFields<F> & ExcludeHookedDBFields<F> & ExcludeDefaultedDBFields<F>, const Opt extends FieldOptions>(fields: F, options?: Opt): TailorDBField<{
  type: "nested";
  array: Opt extends {
    array: true;
  } ? true : false;
}, FieldOutput<InferFieldsOutput<F>, Opt>, F>;
declare const idField: TailorDBFieldInstance<"uuid", FieldOptions, string>;
type idField = typeof idField;
type DBTable<F extends {
  id?: never;
} & Record<string, TailorAnyDBField>, Defined extends DefinedDBTypeMetadata = DefinedDBTypeMetadata> = TailorDBInstance<{
  id: idField;
} & F, InferredAttributes, Defined>;
/**
 * Creates a new database table with the specified fields.
 * An `id` field (UUID) is automatically added to every table.
 * @param name - The name of the table, or a tuple of [name, pluralForm]
 * @param fields - The field definitions for the table
 * @returns A new TailorDB table instance
 * @example
 * export const user = db.table("User", {
 *   name: db.string(),
 *   email: db.string(),
 *   age: db.int({ optional: true }),
 *   role: db.enum(["admin", "member"]),
 *   ...db.fields.timestamps(),
 * });
 * // Always export both the value and type:
 * export type user = typeof user;
 */
declare function dbTable<const F extends {
  id?: never;
} & Record<string, TailorAnyDBField>>(name: string | [string, string], fields: F): DBTable<F>;
/**
 * Creates a new database table with the specified fields and description.
 * An `id` field (UUID) is automatically added to every table.
 * @param name - The name of the table, or a tuple of [name, pluralForm]
 * @param description - A description of the table
 * @param fields - The field definitions for the table
 * @returns A new TailorDB table instance
 */
declare function dbTable<const F extends {
  id?: never;
} & Record<string, TailorAnyDBField>>(name: string | [string, string], description: string, fields: F): DBTable<F, WithDBTypeMetadata<DefinedDBTypeMetadata, "description">>;
type TimestampsUpdatedAtHookFn = UpdateHookFn<string | Date | null, string | Date>;
/** TailorDB schema builder utilities for defining tables and fields. */
export declare const db: {
  table: typeof dbTable;
  uuid: typeof uuid;
  string: typeof string;
  bool: typeof bool;
  int: typeof int;
  float: typeof float;
  decimal: typeof decimal;
  date: typeof date;
  datetime: typeof datetime;
  time: typeof time;
  enum: typeof _enum;
  object: typeof object;
  fields: {
    /**
     * Creates standard timestamp fields (createdAt, updatedAt) with automatic defaults.
     * Both fields default to the current time on create. updatedAt is also refreshed on update.
     * User-specified values are respected when provided (e.g. seeding historical records).
     * @returns An object with createdAt and updatedAt fields
     * @example
     * const model = db.table("Model", {
     *   name: db.string(),
     *   ...db.fields.timestamps(),
     * });
     */
    timestamps: () => {
      createdAt: TailorDBField<WithDBFieldDescription<WithDBFieldDefault<DBFieldDefined<"datetime", FieldOptions>>>, string | Date, Record<string, TailorAnyDBField>>;
      updatedAt: TailorDBField<WithDBFieldDescription<WithDBFieldHooks<WithDBFieldDefault<DBFieldDefined<"datetime", FieldOptions>>, {
        readonly update: TimestampsUpdatedAtHookFn;
      }>>, string | Date, Record<string, TailorAnyDBField>>;
    };
  };
};
//#endregion