import { TypeLevelError, output } from "../types/helpers.mjs";
import { IsAutoFilledDBField, IsReadOnlyDBField, TailorAnyDBField, TailorAnyDBType } from "../configure/services/tailordb/types.mjs";
import { ColumnType, ColumnType as ColumnType$1, Insertable, Insertable as Insertable$1, Kysely, Kysely as Kysely$1, KyselyConfig, KyselyConfig as KyselyConfig$1, Selectable, Selectable as Selectable$1, Transaction, Transaction as Transaction$1, Updateable, Updateable as Updateable$1, sql } from "kysely";
import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
//#region src/kysely/index.d.ts
export type Timestamp = ColumnType$1<Date, Date | string, Date | string>;
type ResolveSelect<T> = T extends ColumnType$1<infer S, unknown, unknown> ? S : T;
type ResolveInsert<T> = T extends ColumnType$1<unknown, infer I, unknown> ? I : T;
type ResolveUpdate<T> = T extends ColumnType$1<unknown, unknown, infer U> ? U : T;
export type ObjectColumnType<T> = ColumnType$1<{ [K in keyof T]-?: Exclude<ResolveSelect<T[K]>, undefined>; }, { [K in keyof T]: ResolveInsert<T[K]>; }, { [K in keyof T]: ResolveUpdate<T[K]>; }>;
export type ArrayColumnType<T> = ColumnType$1<ResolveSelect<T>[], ResolveInsert<T>[], ResolveUpdate<T>[]>;
export type Generated<T> = T extends ColumnType$1<infer S, infer I, infer U> ? ColumnType$1<S, I | undefined, U> : ColumnType$1<T, T | undefined, T>;
type SerialColumnMustBeOmitted = TypeLevelError<"assigned by .serial(); remove it from the input">;
export type Serial<T = string | number> = ColumnType$1<T, SerialColumnMustBeOmitted | undefined, SerialColumnMustBeOmitted | undefined>;
type FlattenColumns<T> = { [K in keyof T]: T[K]; } & {};
export type TailordbKysely<DB> = Kysely$1<DB>;
export type NamespaceDB<NS, N extends keyof NS = keyof NS> = TailordbKysely<NS[N]>;
/**
 * Create a namespace-aware getDB function for generated code.
 * @returns A getDB function that creates Kysely instances for specific namespaces
 */
export declare function createGetDB<NS>(): <const N extends keyof NS & string>(namespace: N, config?: Omit<KyselyConfig$1, "dialect">) => TailordbKysely<NS[N]>;
export type NamespaceTransaction<NS, K extends keyof NS | TailordbKysely<NS[keyof NS]> = keyof NS> = K extends TailordbKysely<infer DB> ? Transaction$1<DB> : K extends keyof NS ? Transaction$1<NS[K]> : never;
export type NamespaceTableName<NS> = { [N in keyof NS]: keyof NS[N]; }[keyof NS];
export type NamespaceTable<NS, T extends NamespaceTableName<NS>> = { [N in keyof NS]: T extends keyof NS[N] ? NS[N][T] : never; }[keyof NS];
export type NamespaceInsertable<NS, T extends NamespaceTableName<NS>> = FlattenColumns<Insertable$1<NamespaceTable<NS, T>>>;
export type NamespaceSelectable<NS, T extends NamespaceTableName<NS>> = FlattenColumns<Selectable$1<NamespaceTable<NS, T>>>;
export type NamespaceUpdateable<NS, T extends NamespaceTableName<NS>> = FlattenColumns<Updateable$1<NamespaceTable<NS, T>>>;
/** What the derived input types accept: a table (`typeof myTable`) or a field collection. */
type TailorDBColumnsSource = TailorAnyDBType | Record<string, TailorAnyDBField>;
type DBFieldsOf<T> = T extends TailorAnyDBType ? T["fields"] : T;
type DBFieldType<F> = F extends TailorAnyDBField ? F["_defined"]["type"] : never;
type IsArrayDBField<F> = F extends TailorAnyDBField ? F["_defined"]["array"] extends true ? true : false : false;
type Unwrapped<F> = Exclude<output<F>, null>;
type ElementOutput<F> = IsArrayDBField<F> extends true ? Unwrapped<F> extends readonly (infer E)[] ? E : Unwrapped<F> : Unwrapped<F>;
type NestedFieldsOf<F> = F extends TailorAnyDBField ? F["fields"] : never;
type NestedProps<Fields> = { -readonly [K in keyof Fields as null extends output<Fields[K]> ? never : K]: DBColumn<Fields[K]>; } & { -readonly [K in keyof Fields as null extends output<Fields[K]> ? K : never]?: DBColumn<Fields[K]>; };
type NestedNeedsColumnType<Fields> = true extends { [K in keyof Fields]: DBFieldType<Fields[K]> extends "date" | "datetime" ? true : null extends output<Fields[K]> ? true : DBFieldType<Fields[K]> extends "nested" ? NestedNeedsColumnType<NestedFieldsOf<Fields[K]>> : Fields[K] extends TailorAnyDBField ? IsAutoFilledDBField<Fields[K]> : false; }[keyof Fields] ? true : false;
type NestedColumn<F> = NestedNeedsColumnType<NestedFieldsOf<F>> extends true ? ObjectColumnType<FlattenColumns<NestedProps<NestedFieldsOf<F>>>> : FlattenColumns<NestedProps<NestedFieldsOf<F>>>;
type ElementColumn<F> = DBFieldType<F> extends "date" | "datetime" ? Timestamp : DBFieldType<F> extends "nested" ? NestedColumn<F> : ElementOutput<F>;
type ArrayedColumn<F> = IsArrayDBField<F> extends true ? ElementColumn<F> extends ColumnType$1<unknown, unknown, unknown> ? ArrayColumnType<ElementColumn<F>> : ElementColumn<F>[] : ElementColumn<F>;
type NullableColumn<F> = null extends output<F> ? ArrayedColumn<F> | null : ArrayedColumn<F>;
type DBColumn<F> = F extends TailorAnyDBField ? IsReadOnlyDBField<F> extends true ? Serial<NullableColumn<F>> : IsAutoFilledDBField<F> extends true ? Generated<NullableColumn<F>> : NullableColumn<F> : never;
type TailorDBColumns<T extends TailorDBColumnsSource> = { [K in keyof DBFieldsOf<T>]: K extends "id" ? Generated<output<DBFieldsOf<T>[K]>> : DBColumn<DBFieldsOf<T>[K]>; };
/**
 * Create input derived from a TailorDB table (`typeof myTable`) or a field collection.
 *
 * Each field resolves to the column type `kyselyTypePlugin` writes for it, so this and
 * the generated table types agree: `.serial()` fields are never caller-supplied,
 * `.default()` / `.hooks({ create })` fields may be omitted, optional fields stay
 * optional, `id` is platform-generated, and a date or datetime reads back as `Date`.
 *
 * Pass a field collection when the fields are a type parameter — a shared module that
 * lets each project extend a table with its own fields cannot name a generated table
 * type. Declare it as `<const F extends Record<string, TailorAnyDBField>>` so the field
 * types are inferred; a bare `Record<string, TailorAnyDBField>` erases them and nothing
 * is checked.
 *
 * Hand the result to callers rather than consuming it inside the generic that declares
 * it: while `F` is still an unresolved type parameter the mapping stays deferred, so
 * assigning to it inside the function body reports the unevaluated conditional rather
 * than a readable shape.
 * @example
 * function createInput<const F extends Record<string, TailorAnyDBField>>(fields: F) {
 *   return (input: TailorDBInsertable<F>) => { ... };
 * }
 */
export type TailorDBInsertable<T extends TailorDBColumnsSource> = FlattenColumns<Insertable$1<TailorDBColumns<T>>>;
/** Read shape of a TailorDB table or field collection. See {@link TailorDBInsertable}. */
export type TailorDBSelectable<T extends TailorDBColumnsSource> = FlattenColumns<Selectable$1<TailorDBColumns<T>>>;
/** Update input for a TailorDB table or field collection. See {@link TailorDBInsertable}. */
export type TailorDBUpdateable<T extends TailorDBColumnsSource> = FlattenColumns<Updateable$1<TailorDBColumns<T>>>;
//#endregion
export { type ColumnType, type Insertable, Kysely, type KyselyConfig, type Selectable, TailordbDialect, type Transaction, type Updateable, sql };