@aurios/mizzle 1.1.1 → 1.1.3

package/dist/operators-BVreW0ky.d.ts

@@ -0,0 +1,719 @@
+declare const INFER_MODE: {
+    readonly QUERY: "query";
+    readonly RAW: "raw";
+};
+declare const ORDER: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};
+declare const NULLS: {
+    readonly FIRST: "first";
+    readonly LAST: "last";
+};
+declare const TABLE_SYMBOLS: {
+    COLUMNS: symbol;
+    INDEXES: symbol;
+    SORT_KEY: symbol;
+    TABLE_NAME: symbol;
+    PARTITION_KEY: symbol;
+};
+declare const ENTITY_SYMBOLS: {
+    ENTITY_NAME: symbol;
+    ENTITY_STRATEGY: symbol;
+    PHYSICAL_TABLE: symbol;
+    COLUMNS: symbol;
+    ENTITY_KIND: symbol;
+};
+declare const RELATION_SYMBOLS: {
+    RELATION_CONFIG: symbol;
+};
+
+type Assume<T, U> = T extends U ? T : U;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Update<T, TUpdate> = {
+    [K in Exclude<keyof T, keyof TUpdate>]: T[K];
+} & TUpdate;
+declare function getEntityColumns<T extends {}>(entity: T): T[typeof ENTITY_SYMBOLS.COLUMNS];
+declare function resolveTableName(entity: {}): string;
+interface MinimalEntity {
+}
+declare function mapToLogical(entity: MinimalEntity, item: Record<string, unknown>): Record<string, unknown>;
+interface ColumnType<TData = unknown, THasDefault extends boolean = boolean> {
+    _$data: TData;
+    _$hasDefault: THasDefault;
+}
+
+type BinaryBuilderInitial<TName extends string> = BinaryColumnBuilder<{
+    name: TName;
+    dataType: "binary";
+    columnType: "B";
+    data: Buffer;
+}>;
+declare class BinaryColumnBuilder<T extends ColumnBuilderBaseConfig<"binary", "B">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): BinaryColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class BinaryColumn<T extends ColumnBaseConfig<"binary", "B">> extends Column<T> {
+}
+declare function binary(): BinaryBuilderInitial<"">;
+declare function binary<TName extends string>(name: TName): BinaryBuilderInitial<TName>;
+
+type BinarySetColumnInitial<TName extends string> = BinarySetColumnBuilder<{
+    name: TName;
+    dataType: "binarySet";
+    columnType: "BS";
+    data: Set<Uint8Array>;
+}>;
+declare class BinarySetColumnBuilder<T extends ColumnBuilderBaseConfig<"binarySet", "BS">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): BinarySetColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class BinarySetColumn<T extends ColumnBaseConfig<"binarySet", "BS">> extends Column<T> {
+}
+declare function binarySet(): BinarySetColumnInitial<"">;
+declare function binarySet<TName extends string>(name: TName): BinarySetColumnInitial<TName>;
+
+type BooleanColumnInitial<TName extends string> = BooleanColumnBuilder<{
+    name: TName;
+    dataType: "boolean";
+    columnType: "BOOL";
+    data: boolean;
+}>;
+declare class BooleanColumnBuilder<T extends ColumnBuilderBaseConfig<"boolean", "BOOL">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): BooleanColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class BooleanColumn<T extends ColumnBaseConfig<"boolean", "BOOL">> extends Column<T> {
+}
+declare function boolean(): BooleanColumnInitial<"">;
+declare function boolean<TName extends string>(name: TName): BooleanColumnInitial<TName>;
+
+type DateColumnInitial<TName extends string> = DateColumnBuilder<{
+    name: TName;
+    dataType: "date";
+    columnType: "S";
+    data: Date;
+}>;
+declare class DateColumnBuilder<T extends ColumnBuilderBaseConfig<"date", "S">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    defaultNow(): HasRuntimeDefault<HasDefault<this>>;
+    onUpdateNow(): HasDefault<this>;
+    build<TTableName extends string>(table: AnyTable): DateColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class DateColumn<T extends ColumnBaseConfig<"date", "S">> extends Column<T> {
+    mapToDynamoValue(value: unknown): unknown;
+    mapFromDynamoValue(value: unknown): unknown;
+}
+declare function date(): DateColumnInitial<"">;
+declare function date<TName extends string>(name: TName): DateColumnInitial<TName>;
+
+type ListColumnInitial<TName extends string> = ListColumnBuilder<{
+    name: TName;
+    data: unknown[];
+    dataType: "array";
+    columnType: "L";
+}>;
+declare class ListColumnBuilder<T extends ColumnBuilderBaseConfig<"array", "L">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): ListColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class ListColumn<T extends ColumnBaseConfig<"array", "L">> extends Column<T> {
+}
+declare function list(): ListColumnInitial<"">;
+declare function list<TName extends string>(name: TName): ListColumnInitial<TName>;
+
+type MapColumnInitial<TName extends string> = MapColumnBuilder<{
+    name: TName;
+    data: Record<string, unknown>;
+    dataType: "map";
+    columnType: "M";
+}>;
+declare class MapColumnBuilder<T extends ColumnBuilderBaseConfig<"map", "M">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): MapColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class MapColumn<T extends ColumnBaseConfig<"map", "M">> extends Column<T> {
+}
+declare function map(): MapColumnInitial<"">;
+declare function map<TName extends string>(name: TName): MapColumnInitial<TName>;
+
+type NumberColumnInitial<TName extends string> = NumberColumnBuilder<{
+    name: TName;
+    dataType: "number";
+    columnType: "N";
+    data: number;
+}>;
+declare class NumberColumnBuilder<T extends ColumnBuilderBaseConfig<"number", "N">> extends ColumnBuider<T, {
+    validators?: {
+        min?: number;
+        max?: number;
+    };
+}> {
+    constructor(name: T["name"]);
+    min(value: number): this;
+    max(value: number): this;
+    build<TTableName extends string>(table: AnyTable): NumberColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class NumberColumn<T extends ColumnBaseConfig<"number", "N">> extends Column<T> {
+}
+declare function number(): NumberColumnInitial<"">;
+declare function number<TName extends string>(name: TName): NumberColumnInitial<TName>;
+
+type NumberSetColumnInitial<TName extends string> = NumberSetColumnBuilder<{
+    name: TName;
+    data: Set<number>;
+    columnType: "NS";
+    dataType: "numberSet";
+}>;
+declare class NumberSetColumnBuilder<T extends ColumnBuilderBaseConfig<"numberSet", "NS">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): NumberSetColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class NumberSetColumn<T extends ColumnBaseConfig<"numberSet", "NS">> extends Column<T> {
+}
+declare function numberSet(): NumberSetColumnInitial<"">;
+declare function numberSet<TName extends string>(name: TName): NumberSetColumnInitial<TName>;
+
+type StringColumnInitial<TName extends string> = StringColumnBuilder<{
+    name: TName;
+    dataType: "string";
+    columnType: "S";
+    data: string;
+}>;
+declare class StringColumnBuilder<T extends ColumnBuilderBaseConfig<"string", "S">> extends ColumnBuider<T, {
+    validators?: {
+        length?: number;
+        email?: boolean;
+    };
+}> {
+    constructor(name: string);
+    length(value: number): this;
+    email(): this;
+    /** @internal */
+    build<TTableName extends string>(table: AnyTable): StringColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class StringColumn<T extends ColumnBaseConfig<"string", "S">> extends Column<T> {
+}
+declare function string(): StringColumnInitial<"">;
+declare function string<TName extends string>(name: TName): StringColumnInitial<TName>;
+
+type StringSetColumnInitial<TName extends string> = StringSetColumnBuilder<{
+    name: TName;
+    dataType: "string";
+    columnType: "SS";
+    data: Set<string>;
+}>;
+declare class StringSetColumnBuilder<T extends ColumnBuilderBaseConfig<"string", "SS">> extends ColumnBuider<T> {
+    constructor(name: string);
+    default(value: this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"]): HasDefault<this>;
+    build<TTableName extends string>(table: AnyTable): StringSetColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class StringSetColumn<T extends ColumnBaseConfig<"string", "SS">> extends Column<T> {
+}
+declare function stringSet(): StringSetColumnInitial<"">;
+declare function stringSet<TName extends string>(name: TName): StringSetColumnInitial<TName>;
+
+type UUIDColumnInitial<TName extends string> = UUIDColumnBuilder<{
+    name: TName;
+    dataType: "string";
+    columnType: "S";
+    data: string;
+}>;
+declare class UUIDColumnBuilder<T extends ColumnBuilderBaseConfig<"string", "S">> extends ColumnBuider<T> {
+    constructor(name: string);
+    /** @internal */
+    build<TTableName extends string>(table: AnyTable): UUIDColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class UUIDColumn<T extends ColumnBaseConfig<"string", "S">> extends Column<T> {
+}
+declare function uuid(): UUIDColumnInitial<"">;
+declare function uuid<TName extends string>(name: TName): UUIDColumnInitial<TName>;
+
+type JsonColumnInitial<TName extends string> = JsonColumnBuilder<{
+    name: TName;
+    dataType: "json";
+    columnType: "S";
+    data: unknown;
+}>;
+declare class JsonColumnBuilder<T extends ColumnBuilderBaseConfig<"json", "S">> extends ColumnBuider<T> {
+    constructor(name: T["name"]);
+    build<TTableName extends string>(table: AnyTable): JsonColumn<MakeColumnConfig<T, TTableName>>;
+}
+declare class JsonColumn<T extends ColumnBaseConfig<"json", "S">> extends Column<T> {
+    mapToDynamoValue(value: T["data"]): string;
+    mapFromDynamoValue(value: T["data"] | string): T["data"];
+}
+declare function json(): JsonColumnInitial<"">;
+declare function json<TName extends string>(name: TName): JsonColumnInitial<TName>;
+
+declare function getColumnBuilders(): {
+    binary: typeof binary;
+    binarySet: typeof binarySet;
+    boolean: typeof boolean;
+    date: typeof date;
+    json: typeof json;
+    list: typeof list;
+    map: typeof map;
+    number: typeof number;
+    numberSet: typeof numberSet;
+    string: typeof string;
+    stringSet: typeof stringSet;
+    uuid: typeof uuid;
+};
+type ColumnsBuilder = ReturnType<typeof getColumnBuilders>;
+
+interface IndexColumnConfig {
+    pk?: string;
+    sk?: string;
+}
+declare class IndexBuilder {
+    type: "gsi" | "lsi";
+    config: IndexColumnConfig;
+    constructor(type: "gsi" | "lsi", config: IndexColumnConfig);
+}
+declare function gsi(pkColumn: string, skColumn?: string): IndexBuilder;
+declare function lsi(skColumn: string): IndexBuilder;
+
+type RequiredKeyOnly<TKey extends string, T extends Column, TInferMode extends "select" | "insert" = "select"> = TInferMode extends "select" ? never : T extends AnyColumn<{
+    hasDefault: false;
+    notNull: true;
+}> ? TKey : never;
+type OpitionalKeyOnly<TKey extends string, T extends Column, TInferMode extends "select" | "insert" = "select"> = TKey extends RequiredKeyOnly<TKey, T, TInferMode> ? never : TKey;
+type SelectedFieldsFlat<TColumn extends Column> = Record<string, TColumn>;
+type SelectedFields<TColumn extends Column, TTable extends PhysicalTable> = Record<string, SelectedFieldsFlat<TColumn>[string] | TTable | SelectedFieldsFlat<TColumn>>;
+
+type KeyStrategyType = "static" | "prefix" | "composite";
+interface KeyStrategy {
+    type: KeyStrategyType;
+    segments: (string | Column)[];
+    separator?: string;
+}
+/**
+ * SK = "METADATA"
+ */
+declare function staticKey(value: string): KeyStrategy;
+/**
+ * PK = "USER#" + id
+ */
+declare function prefixKey(prefix: string, column: Column): KeyStrategy;
+/**
+ * SK = "ORDER#" + date + "#STATUS#" + status
+ */
+declare function compositeKey(separator: string, ...segments: (string | Column)[]): KeyStrategy;
+interface StrategyResolution {
+    keys: Record<string, unknown>;
+    hasPartitionKey: boolean;
+    hasSortKey: boolean;
+    indexName?: string;
+}
+declare function resolveStrategies(entity: Entity, whereClause?: Expression, providedValues?: Record<string, unknown>, forcedIndexName?: string): StrategyResolution;
+
+type IndexStrategyConfig<TIndex extends IndexBuilder> = TIndex["type"] extends "lsi" ? {
+    sk: KeyStrategy | Column;
+} : {
+    pk: KeyStrategy | Column;
+    sk?: KeyStrategy | Column;
+};
+type IndexesStrategy<TIndexes extends Record<string, IndexBuilder> | undefined> = TIndexes extends Record<string, IndexBuilder> ? {
+    [K in keyof TIndexes]?: IndexStrategyConfig<TIndexes[K]>;
+} : object;
+type StrategyCallback<TColumns extends Record<string, Column>, TPhysicalConfig extends PhysicalTableConfig> = (columns: TColumns) => {
+    [K in keyof TPhysicalConfig as K extends "pk" | "sk" ? K : never]: KeyStrategy | Column;
+} & IndexesStrategy<TPhysicalConfig["indexes"]>;
+interface EntityConfig<TColumn extends Column = Column> {
+    name: string;
+    table: PhysicalTable;
+    columns: Record<string, TColumn>;
+}
+interface PhysicalTableConfig {
+    pk: ColumnBuilderBase;
+    sk?: ColumnBuilderBase;
+    indexes?: Record<string, IndexBuilder>;
+}
+declare class PhysicalTable<T extends PhysicalTableConfig = PhysicalTableConfig> {
+    /** @internal */
+    [TABLE_SYMBOLS.TABLE_NAME]: string;
+    /** @internal */
+    [TABLE_SYMBOLS.INDEXES]: T["indexes"];
+    /** @internal */
+    [TABLE_SYMBOLS.PARTITION_KEY]: Column<ColumnBaseConfig<string, ColumnDataType>, object, object>;
+    /** @internal */
+    [TABLE_SYMBOLS.SORT_KEY]?: Column<ColumnBaseConfig<string, ColumnDataType>, object, object> | undefined;
+    readonly _: {
+        config: T;
+        name: string;
+        partitionKey: Column;
+        sortKey?: Column;
+        indexes: T["indexes"];
+    };
+    static readonly Symbol: {
+        COLUMNS: symbol;
+        INDEXES: symbol;
+        SORT_KEY: symbol;
+        TABLE_NAME: symbol;
+        PARTITION_KEY: symbol;
+    };
+    constructor(name: string, config: T);
+}
+declare class Entity<T extends EntityConfig = EntityConfig> {
+    /** @internal */
+    [ENTITY_SYMBOLS.ENTITY_NAME]: string;
+    /** @internal */
+    [ENTITY_SYMBOLS.PHYSICAL_TABLE]: T["table"];
+    /** @internal */
+    [ENTITY_SYMBOLS.COLUMNS]: T["columns"];
+    [ENTITY_SYMBOLS.ENTITY_STRATEGY]: Record<string, KeyStrategy>;
+    readonly _: {
+        readonly config: T;
+        readonly name: T["name"];
+        readonly table: T["table"];
+        readonly columns: T["columns"];
+        readonly strategies: Record<string, KeyStrategy>;
+        readonly inferSelect: InferSelectModel<Entity<T>>;
+        readonly inferInsert: InferInsertModel<Entity<T>>;
+    };
+    readonly $inferSelect: InferSelectModel<Entity<T>>;
+    readonly $inferInsert: InferInsertModel<Entity<T>>;
+    static readonly Symbol: {
+        ENTITY_NAME: symbol;
+        ENTITY_STRATEGY: symbol;
+        PHYSICAL_TABLE: symbol;
+        COLUMNS: symbol;
+        ENTITY_KIND: symbol;
+    };
+    constructor(name: T["name"], table: T["table"], columns: T["columns"], strategies: Record<string, KeyStrategy>);
+}
+type MapColumnName<TName extends string, TColumn extends Column, TDBColumnNames extends boolean> = TDBColumnNames extends true ? TColumn["_"]["name"] : TName;
+type InferModelFromColumns<TColumns extends Record<string, Column>, TInferMode extends "select" | "insert" = "select", TConfig extends {
+    dbColumnNames: boolean;
+    override?: boolean;
+} = {
+    dbColumnNames: false;
+    override: false;
+}> = Simplify<{
+    [Key in keyof TColumns & string as RequiredKeyOnly<MapColumnName<Key, TColumns[Key], TConfig["dbColumnNames"]>, TColumns[Key], TInferMode>]: GetColumnData<TColumns[Key], typeof INFER_MODE.QUERY>;
+} & {
+    [Key in keyof TColumns & string as OpitionalKeyOnly<MapColumnName<Key, TColumns[Key], TConfig["dbColumnNames"]>, TColumns[Key], TInferMode>]?: GetColumnData<TColumns[Key], typeof INFER_MODE.QUERY> | undefined;
+}>;
+type InferSelectModel<TTable extends Entity, TConfig extends {
+    dbColumnNames: boolean;
+} = {
+    dbColumnNames: false;
+}> = InferModelFromColumns<TTable["_"]["columns"], "select", TConfig>;
+type InferInsertModel<TTable extends Entity, TConfig extends {
+    dbColumnNames: boolean;
+    override?: boolean;
+} = {
+    dbColumnNames: false;
+    override: false;
+}> = InferModelFromColumns<TTable["_"]["columns"], "insert", TConfig>;
+type InferSelectedModel<TTable extends Entity, TConfig extends {
+    dbColumnNames: boolean;
+} = {
+    dbColumnNames: false;
+}> = InferSelectModel<TTable, TConfig>;
+type TableDefinition<T extends EntityConfig = EntityConfig> = Entity<T> & {
+    columns: T["columns"];
+};
+type AtomicValues<T extends Entity> = Partial<InferInsertModel<T>>;
+type EntityWithColumns<T extends EntityConfig> = Entity<T> & {
+    [Key in keyof T["columns"]]: T["columns"][Key];
+};
+type UpdateTableConfig<T extends PhysicalTableConfig, TUpdate extends Partial<PhysicalTableConfig>> = Required<Update<T, TUpdate>>;
+type AnyTable<TPartial extends Partial<PhysicalTableConfig> = object> = PhysicalTable<UpdateTableConfig<PhysicalTableConfig, TPartial>>;
+/**
+ * Defines a logical entity that maps to items within a DynamoDB table.
+ *
+ * @example
+ * ```ts
+ * const users = dynamoEntity(table, "users", {
+ *   id: string("id"),
+ *   name: string("name"),
+ *   email: string("email"),
+ * });
+ * ```
+ *
+ * @param table The physical table definition this entity belongs to.
+ * @param name The unique name of the entity (used for typing and potentially in single-table design discriminators).
+ * @param columns A map of column definitions or a callback to define columns.
+ * @param strategies Optional configuration for key generation strategies (PK/SK construction).
+ * @returns The entity definition with strict typing.
+ */
+declare function dynamoEntity<TName extends string, TTable extends PhysicalTable, TColumnsMap extends Record<string, ColumnBuilderBase>>(table: TTable, name: TName, columns: TColumnsMap | ((columnsTypes: ColumnsBuilder) => TColumnsMap), strategies?: StrategyCallback<BuildColumns<TName, TColumnsMap>, TTable["_"]["config"]>): EntityWithColumns<{
+    name: TName;
+    table: TTable;
+    columns: BuildColumns<TName, TColumnsMap>;
+}>;
+/**
+ * Defines a physical DynamoDB table schema.
+ *
+ * @example
+ * ```ts
+ * const table = dynamoTable("my-app-table", {
+ *   pk: string("pk"),
+ *   sk: string("sk"),
+ * });
+ * ```
+ *
+ * @param name The actual name of the table in DynamoDB (or a reference name).
+ * @param config The table configuration, including primary key (pk) and sort key (sk) definitions.
+ * @returns A PhysicalTable instance representing the table schema.
+ */
+declare function dynamoTable<TTableName extends string, TConfig extends PhysicalTableConfig>(name: TTableName, config: TConfig): PhysicalTable<TConfig>;
+
+type ColumnDataType = "S" | "N" | "BOOL" | "M" | "L" | "B" | "BS" | "NS" | "NULL" | "SS";
+interface ColumnBuilderBaseConfig<TDataType extends string, TColumnDataType extends ColumnDataType> {
+    name: string;
+    dataType: TDataType;
+    columnType: TColumnDataType;
+    data: unknown;
+}
+type MakeColumnConfig<T extends ColumnBuilderBaseConfig<string, ColumnDataType>, TTableName extends string, TData = T extends {
+    $type: infer U;
+} ? U : T["data"]> = {
+    name: T["name"];
+    tableName: TTableName;
+    dataType: T["dataType"];
+    columnType: T["columnType"];
+    data: TData;
+    notNull: T extends {
+        notNull: true;
+    } ? true : false;
+    hasDefault: T extends {
+        hasDefault: true;
+    } ? true : false;
+    hasRuntimeDefault: T extends {
+        hasRuntimeDefault: true;
+    } ? true : false;
+    isPartitionKey: T extends {
+        isPartitionKey: true;
+    } ? true : false;
+    isSortKey: T extends {
+        isSortKey: true;
+    } ? true : false;
+} & object;
+type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = object> = {
+    name: string;
+    notNull: boolean;
+    default: TData;
+    dataType: string;
+    columnType: string;
+    isPartitionKey: boolean;
+    isSortKey: boolean;
+    hasDefault: boolean;
+    partitionKey: boolean;
+    sortKey: boolean;
+    defaultFn: () => TData | undefined;
+    onUpdateFn: () => TData | undefined;
+} & TRuntimeConfig;
+type ColumnBuilderTypeConfig<T extends ColumnBuilderBaseConfig<string, ColumnDataType>, TTypeConfig extends object = object> = Simplify<{
+    name: T["name"];
+    dataType: T["dataType"];
+    data: T["data"];
+    columnType: T["columnType"];
+    notNull: T extends {
+        notNull: infer U;
+    } ? U : boolean;
+    hasDefault: T extends {
+        hasDefault: infer U;
+    } ? U : boolean;
+    isPartitionKey: T extends {
+        isPartitionKey: infer U;
+    } ? U : boolean;
+    isSortKey: T extends {
+        isSortKey: infer U;
+    } ? U : boolean;
+} & TTypeConfig>;
+interface ColumnBuilderBase<T extends ColumnBuilderBaseConfig<string, ColumnDataType> = ColumnBuilderBaseConfig<string, ColumnDataType>, TTypeConfig extends object = object> {
+    _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+}
+interface ColumnBuiderExtraConfig {
+    partitionKeyHasDefault?: boolean;
+}
+type NotNull<T extends ColumnBuilderBase> = T & {
+    _: {
+        notNull: true;
+    };
+};
+type HasDefault<T extends ColumnBuilderBase> = T & {
+    _: {
+        hasDefault: true;
+    };
+};
+type HasRuntimeDefault<T extends ColumnBuilderBase> = T & {
+    _: {
+        hasRuntimeDefault: true;
+    };
+};
+type IsPartitionKey<T extends ColumnBuilderBase> = T & {
+    _: {
+        isPartitionKey: true;
+        notNull: false;
+    };
+};
+type IsSortKey<T extends ColumnBuilderBase> = T & {
+    _: {
+        isSortKey: true;
+        notNull: false;
+    };
+};
+type $Type<T extends ColumnBuilderBase, TType> = T & {
+    _: {
+        $type: TType;
+    };
+};
+type BuildColumn<TTableName extends string, TBuilder extends ColumnBuilderBase> = Column<MakeColumnConfig<TBuilder["_"], TTableName>, object, Simplify<Omit<TBuilder["_"], keyof MakeColumnConfig<TBuilder["_"], TTableName>>>>;
+type BuildColumns<TTableName extends string, TConfigMap extends Record<string, ColumnBuilderBase>> = Simplify<{
+    [Key in keyof TConfigMap]: BuildColumn<TTableName, {
+        _: Omit<TConfigMap[Key]["_"], "name"> & {
+            name: TConfigMap[Key]["_"]["name"] extends "" ? Assume<Key, string> : TConfigMap[Key]["_"]["name"];
+        };
+    }>;
+}>;
+declare abstract class ColumnBuider<T extends ColumnBuilderBaseConfig<string, ColumnDataType> = ColumnBuilderBaseConfig<string, ColumnDataType>, TRuntimeConfig extends object = object, TTypeConfig extends object = object, TExtraConfig extends ColumnBuiderExtraConfig = ColumnBuiderExtraConfig> implements ColumnBuilderBase<T, TTypeConfig> {
+    _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+    config: ColumnBuilderRuntimeConfig<T["data"], TRuntimeConfig>;
+    constructor(name: T["name"], dataType: T["dataType"], columnType: T["columnType"]);
+    default(value: this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"]): HasDefault<this>;
+    $defaultFn(fn: () => this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"]): HasRuntimeDefault<HasDefault<this>>;
+    $onUpdateFn(fn: () => this["_"] extends {
+        $type: infer U;
+    } ? U : this["_"]["data"]): HasDefault<this>;
+    /**
+     * Change de data type of the column.
+     *
+     * ```ts
+     * const users = dynamoTable('users', {
+     *  details: map().$type<UserDetails>().nullable()
+     * });
+     * ```
+     */
+    $type<TType>(): $Type<this, TType>;
+    /** @internal */
+    getConfig(): ColumnBuilderRuntimeConfig<T["data"], TRuntimeConfig>;
+    partitionKey(): TExtraConfig["partitionKeyHasDefault"] extends true ? IsPartitionKey<HasDefault<NotNull<this>>> : IsPartitionKey<NotNull<this>>;
+    sortKey(): IsSortKey<this>;
+    /**
+     * Turns a column nullable.
+     *
+     * ```ts
+     * const users = dynamoTable('users', {
+     *  name: string().nullable()
+     * });
+     * ```
+     */
+    notNull(): NotNull<this>;
+    /** @internal */
+    setName(name: string): void;
+    /** @internal */
+    abstract build<TTableName extends string>(table: AnyTable): Column<MakeColumnConfig<T, TTableName>>;
+}
+
+type AnyColumn<TPartial extends Partial<ColumnBaseConfig<string, ColumnDataType>> = Record<string, never>> = Column<Required<Update<ColumnBaseConfig<string, ColumnDataType>, TPartial>>>;
+interface ColumnBaseConfig<TDataType extends string, TColumnType extends ColumnDataType> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+    tableName: string;
+    name: string;
+    notNull: boolean;
+    hasDefault: boolean;
+    hasRuntimeDefault: boolean;
+    isPartitionKey: boolean;
+    isSortKey: boolean;
+    validators?: Record<string, unknown>;
+}
+type ColumnTypeConfig<T extends ColumnBaseConfig<string, ColumnDataType>, TTypeConfig extends object> = T & {
+    tableName: T["tableName"];
+    name: T["name"];
+    dataType: T["dataType"];
+    columnType: T["columnType"];
+    data: T["data"];
+    notNull: T["notNull"];
+    hasDefault: T["hasDefault"];
+    hasRuntimeDefault: T["hasRuntimeDefault"];
+    isPartitionKey: T["isPartitionKey"];
+    isSortKey: T["isSortKey"];
+} & TTypeConfig;
+type ColumnRuntimeConfig<TData, TRuntimeConfig extends object> = ColumnBuilderRuntimeConfig<TData, TRuntimeConfig>;
+declare abstract class Column<T extends ColumnBaseConfig<string, ColumnDataType> = ColumnBaseConfig<string, ColumnDataType>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> {
+    readonly table: PhysicalTable;
+    readonly _: ColumnTypeConfig<T, TTypeConfig>;
+    readonly name: string;
+    readonly primary: boolean;
+    readonly notNull: boolean;
+    readonly default: T["data"] | undefined;
+    readonly defaultFn: () => T["data"] | undefined;
+    readonly onUpdateFn: () => T["data"] | undefined;
+    readonly hasDefault: boolean;
+    readonly dataType: T["dataType"];
+    readonly columnType: T["columnType"];
+    protected config: ColumnRuntimeConfig<T["data"], TRuntimeConfig>;
+    constructor(table: PhysicalTable, config: ColumnRuntimeConfig<T["data"], TRuntimeConfig>);
+    getDynamoType(): string;
+    mapFromDynamoValue(value: unknown): unknown;
+    mapToDynamoValue(value: unknown): unknown;
+}
+type GetColumnData<TColumn extends Column, TInferMode extends "query" | "raw" = "query"> = TInferMode extends typeof INFER_MODE.RAW ? TColumn["_"]["data"] : TColumn["_"]["notNull"] extends false ? TColumn["_"]["data"] : TColumn["_"]["data"] | null;
+
+type BinaryOperators = "=" | "<" | "<=" | ">=" | ">" | "between" | "in";
+type LogicalOperators = "AND" | "OR";
+type FunctionOperators = "begins_with" | "contains" | "attribute_exists";
+declare abstract class Expression {
+    abstract readonly type: "binary" | "logical" | "function";
+}
+declare class BinaryExpression extends Expression {
+    readonly column: Column;
+    readonly operator: BinaryOperators;
+    readonly value: unknown;
+    readonly type = "binary";
+    constructor(column: Column, operator: BinaryOperators, value: unknown);
+}
+declare class LogicalExpression extends Expression {
+    readonly conditions: Expression[];
+    readonly operator: LogicalOperators;
+    readonly type = "logical";
+    constructor(conditions: Expression[], operator: LogicalOperators);
+}
+declare class FunctionExpression extends Expression {
+    readonly column: Column;
+    readonly operator: FunctionOperators;
+    readonly value: unknown;
+    readonly type = "function";
+    constructor(column: Column, operator: FunctionOperators, value: unknown);
+}
+declare function eq(column: Column, value: unknown): BinaryExpression;
+declare function gt(column: Column, value: unknown): BinaryExpression;
+declare function gte(column: Column, value: unknown): BinaryExpression;
+declare function lt(column: Column, value: unknown): BinaryExpression;
+declare function lte(column: Column, value: unknown): BinaryExpression;
+declare function between(column: Column, values: [unknown, unknown]): BinaryExpression;
+declare function inList(column: Column, values: unknown[]): BinaryExpression;
+declare function beginsWith(column: Column, value: string): FunctionExpression;
+declare function contains(column: Column, value: unknown): FunctionExpression;
+declare function attributeExists(column: Column): FunctionExpression;
+declare function or(...conditions: Expression[]): LogicalExpression;
+declare function and(...conditions: Expression[]): LogicalExpression;
+declare const operators: {
+    eq: typeof eq;
+    gt: typeof gt;
+    gte: typeof gte;
+    lt: typeof lt;
+    lte: typeof lte;
+    between: typeof between;
+    in: typeof inList;
+    and: typeof and;
+    or: typeof or;
+    contains: typeof contains;
+    beginsWith: typeof beginsWith;
+    attributeExists: typeof attributeExists;
+};
+type Operators = typeof operators;
+type Condition = Expression;
+
+export { gt as $, type AnyTable as A, BinaryExpression as B, type ColumnType as C, binarySet as D, Expression as E, FunctionExpression as F, boolean as G, compositeKey as H, INFER_MODE as I, contains as J, type KeyStrategy as K, LogicalExpression as L, type MapColumnName as M, NULLS as N, ORDER as O, PhysicalTable as P, date as Q, RELATION_SYMBOLS as R, type Simplify as S, TABLE_SYMBOLS as T, type Update as U, dynamoEntity as V, dynamoTable as W, eq as X, getColumnBuilders as Y, getEntityColumns as Z, gsi as _, type Assume as a, gte as a0, inList as a1, json as a2, list as a3, lsi as a4, lt as a5, lte as a6, map as a7, mapToLogical as a8, number as a9, numberSet as aa, operators as ab, or as ac, prefixKey as ad, resolveStrategies as ae, resolveTableName as af, staticKey as ag, string as ah, stringSet as ai, uuid as aj, Column as ak, type ColumnBaseConfig as al, type ColumnDataType as am, type AnyColumn as an, type OpitionalKeyOnly as ao, type SelectedFields as ap, type AtomicValues as b, type ColumnsBuilder as c, type Condition as d, ENTITY_SYMBOLS as e, Entity as f, type EntityConfig as g, type EntityWithColumns as h, IndexBuilder as i, type IndexColumnConfig as j, type InferInsertModel as k, type InferModelFromColumns as l, type InferSelectModel as m, type InferSelectedModel as n, type KeyStrategyType as o, type Operators as p, type PhysicalTableConfig as q, type StrategyCallback as r, type StrategyResolution as s, type TableDefinition as t, type UpdateTableConfig as u, and as v, attributeExists as w, beginsWith as x, between as y, binary as z };