npm - @m5kdev/web-ui - Versions diffs - 0.8.7 → 0.8.8 - Mend

@m5kdev/web-ui 0.8.7 → 0.8.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (866) hide show

package/dist/node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/column-builder.d.ts ADDED Viewed

@@ -0,0 +1,116 @@
+import { SQL } from "./sql/sql.js";
+import { Simplify } from "./utils.js";
+import { GelColumn } from "./gel-core/columns/common.js";
+import { MySqlColumn } from "./mysql-core/columns/common.js";
+import { PgSequenceOptions } from "./pg-core/sequence.js";
+import { PgColumn } from "./pg-core/columns/common.js";
+import { SingleStoreColumn } from "./singlestore-core/columns/common.js";
+import { SQLiteColumn } from "./sqlite-core/columns/common.js";
+import { Column } from "./column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/column-builder.d.ts
+type ColumnDataType = 'string' | 'number' | 'boolean' | 'array' | 'json' | 'date' | 'bigint' | 'custom' | 'buffer' | 'dateDuration' | 'duration' | 'relDuration' | 'localTime' | 'localDate' | 'localDateTime';
+type Dialect = 'pg' | 'mysql' | 'sqlite' | 'singlestore' | 'common' | 'gel';
+type GeneratedStorageMode = 'virtual' | 'stored';
+type GeneratedType = 'always' | 'byDefault';
+type GeneratedColumnConfig<TDataType> = {
+  as: TDataType | SQL | (() => SQL);
+  type?: GeneratedType;
+  mode?: GeneratedStorageMode;
+};
+type GeneratedIdentityConfig = {
+  sequenceName?: string;
+  sequenceOptions?: PgSequenceOptions;
+  type: 'always' | 'byDefault';
+};
+interface ColumnBuilderBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> {
+  name: string;
+  dataType: TDataType;
+  columnType: TColumnType;
+  data: unknown;
+  driverParam: unknown;
+  enumValues: string[] | undefined;
+}
+type MakeColumnConfig<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, 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;
+  driverParam: T['driverParam'];
+  notNull: T extends {
+    notNull: true;
+  } ? true : false;
+  hasDefault: T extends {
+    hasDefault: true;
+  } ? true : false;
+  isPrimaryKey: T extends {
+    isPrimaryKey: true;
+  } ? true : false;
+  isAutoincrement: T extends {
+    isAutoincrement: true;
+  } ? true : false;
+  hasRuntimeDefault: T extends {
+    hasRuntimeDefault: true;
+  } ? true : false;
+  enumValues: T['enumValues'];
+  baseColumn: T extends {
+    baseBuilder: infer U extends ColumnBuilderBase;
+  } ? BuildColumn<TTableName, U, 'common'> : never;
+  identity: T extends {
+    identity: 'always';
+  } ? 'always' : T extends {
+    identity: 'byDefault';
+  } ? 'byDefault' : undefined;
+  generated: T extends {
+    generated: infer G;
+  } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined;
+} & {};
+type ColumnBuilderTypeConfig<T extends ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> = Simplify<{
+  brand: 'ColumnBuilder';
+  name: T['name'];
+  dataType: T['dataType'];
+  columnType: T['columnType'];
+  data: T['data'];
+  driverParam: T['driverParam'];
+  notNull: T extends {
+    notNull: infer U;
+  } ? U : boolean;
+  hasDefault: T extends {
+    hasDefault: infer U;
+  } ? U : boolean;
+  enumValues: T['enumValues'];
+  identity: T extends {
+    identity: infer U;
+  } ? U : unknown;
+  generated: T extends {
+    generated: infer G;
+  } ? G extends undefined ? unknown : G : unknown;
+} & TTypeConfig>;
+type ColumnBuilderRuntimeConfig<TData, TRuntimeConfig extends object = object> = {
+  name: string;
+  keyAsName: boolean;
+  notNull: boolean;
+  default: TData | SQL | undefined;
+  defaultFn: (() => TData | SQL) | undefined;
+  onUpdateFn: (() => TData | SQL) | undefined;
+  hasDefault: boolean;
+  primaryKey: boolean;
+  isUnique: boolean;
+  uniqueName: string | undefined;
+  uniqueType: string | undefined;
+  dataType: string;
+  columnType: string;
+  generated: GeneratedColumnConfig<TData> | undefined;
+  generatedIdentity: GeneratedIdentityConfig | undefined;
+} & TRuntimeConfig;
+interface ColumnBuilderBase<T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>, TTypeConfig extends object = object> {
+  _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+}
+type BuildColumn<TTableName extends string, TBuilder extends ColumnBuilderBase, TDialect extends Dialect> = TDialect extends 'pg' ? PgColumn<MakeColumnConfig<TBuilder['_'], TTableName>, {}, Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>> : TDialect extends 'mysql' ? MySqlColumn<MakeColumnConfig<TBuilder['_'], TTableName>, {}, Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect' | 'primaryKeyHasDefault' | 'mysqlColumnBuilderBrand'>>> : TDialect extends 'sqlite' ? SQLiteColumn<MakeColumnConfig<TBuilder['_'], TTableName>, {}, Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>> : TDialect extends 'common' ? Column<MakeColumnConfig<TBuilder['_'], TTableName>, {}, Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>> : TDialect extends 'singlestore' ? SingleStoreColumn<MakeColumnConfig<TBuilder['_'], TTableName>, {}, Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect' | 'primaryKeyHasDefault' | 'singlestoreColumnBuilderBrand'>>> : TDialect extends 'gel' ? GelColumn<MakeColumnConfig<TBuilder['_'], TTableName>, {}, Simplify<Omit<TBuilder['_'], keyof MakeColumnConfig<TBuilder['_'], TTableName> | 'brand' | 'dialect'>>> : never;
+type ChangeColumnTableName<TColumn extends Column, TAlias extends string, TDialect extends Dialect> = TDialect extends 'pg' ? PgColumn<MakeColumnConfig<TColumn['_'], TAlias>> : TDialect extends 'mysql' ? MySqlColumn<MakeColumnConfig<TColumn['_'], TAlias>> : TDialect extends 'singlestore' ? SingleStoreColumn<MakeColumnConfig<TColumn['_'], TAlias>> : TDialect extends 'sqlite' ? SQLiteColumn<MakeColumnConfig<TColumn['_'], TAlias>> : TDialect extends 'gel' ? GelColumn<MakeColumnConfig<TColumn['_'], TAlias>> : never;
+//#endregion
+export { ChangeColumnTableName, ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, ColumnDataType, Dialect, GeneratedColumnConfig, GeneratedIdentityConfig };
+//# sourceMappingURL=column-builder.d.ts.map

@@ -0,0 +1,69 @@
+import { entityKind } from "./entity.js";
+import { Table } from "./table.js";
+import { DriverValueMapper, SQL, SQLWrapper } from "./sql/sql.js";
+import { Update } from "./utils.js";
+import { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, ColumnDataType, GeneratedColumnConfig, GeneratedIdentityConfig } from "./column-builder.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/column.d.ts
+interface ColumnBaseConfig<TDataType extends ColumnDataType, TColumnType extends string> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+  tableName: string;
+  notNull: boolean;
+  hasDefault: boolean;
+  isPrimaryKey: boolean;
+  isAutoincrement: boolean;
+  hasRuntimeDefault: boolean;
+}
+type ColumnTypeConfig<T extends ColumnBaseConfig<ColumnDataType, string>, TTypeConfig extends object> = T & {
+  brand: 'Column';
+  tableName: T['tableName'];
+  name: T['name'];
+  dataType: T['dataType'];
+  columnType: T['columnType'];
+  data: T['data'];
+  driverParam: T['driverParam'];
+  notNull: T['notNull'];
+  hasDefault: T['hasDefault'];
+  isPrimaryKey: T['isPrimaryKey'];
+  isAutoincrement: T['isAutoincrement'];
+  hasRuntimeDefault: T['hasRuntimeDefault'];
+  enumValues: T['enumValues'];
+  baseColumn: T extends {
+    baseColumn: infer U;
+  } ? U : unknown;
+  generated: GeneratedColumnConfig<T['data']> | undefined;
+  identity: undefined | 'always' | 'byDefault';
+} & TTypeConfig;
+type ColumnRuntimeConfig<TData, TRuntimeConfig extends object> = ColumnBuilderRuntimeConfig<TData, TRuntimeConfig>;
+interface Column<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> extends DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {}
+declare abstract class Column<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = object, TTypeConfig extends object = object> implements DriverValueMapper<T['data'], T['driverParam']>, SQLWrapper {
+  readonly table: Table;
+  static readonly [entityKind]: string;
+  readonly _: ColumnTypeConfig<T, TTypeConfig>;
+  readonly name: string;
+  readonly keyAsName: boolean;
+  readonly primary: boolean;
+  readonly notNull: boolean;
+  readonly default: T['data'] | SQL | undefined;
+  readonly defaultFn: (() => T['data'] | SQL) | undefined;
+  readonly onUpdateFn: (() => T['data'] | SQL) | undefined;
+  readonly hasDefault: boolean;
+  readonly isUnique: boolean;
+  readonly uniqueName: string | undefined;
+  readonly uniqueType: string | undefined;
+  readonly dataType: T['dataType'];
+  readonly columnType: T['columnType'];
+  readonly enumValues: T['enumValues'];
+  readonly generated: GeneratedColumnConfig<T['data']> | undefined;
+  readonly generatedIdentity: GeneratedIdentityConfig | undefined;
+  protected config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>;
+  constructor(table: Table, config: ColumnRuntimeConfig<T['data'], TRuntimeConfig>);
+  abstract getSQLType(): string;
+  mapFromDriverValue(value: unknown): unknown;
+  mapToDriverValue(value: unknown): unknown;
+}
+type UpdateColConfig<T extends ColumnBaseConfig<ColumnDataType, string>, TUpdate extends Partial<ColumnBaseConfig<ColumnDataType, string>>> = Update<T, TUpdate>;
+type AnyColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = Column<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;
+type GetColumnData<TColumn extends Column, TInferMode extends 'query' | 'raw' = 'query'> = TInferMode extends 'raw' ? TColumn['_']['data'] : TColumn['_']['notNull'] extends true ? TColumn['_']['data'] : TColumn['_']['data'] | null;
+//#endregion
+export { AnyColumn, Column, ColumnBaseConfig, GetColumnData, UpdateColConfig };
+//# sourceMappingURL=column.d.ts.map

@@ -0,0 +1,5 @@
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/entity.d.ts
+declare const entityKind: unique symbol;
+//#endregion
+export { entityKind };
+//# sourceMappingURL=entity.d.ts.map

@@ -0,0 +1,16 @@
+import { entityKind } from "../../entity.js";
+import { GelTable } from "../table.js";
+import { ColumnBuilderRuntimeConfig, ColumnDataType } from "../../column-builder.js";
+import { Column, ColumnBaseConfig } from "../../column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/gel-core/columns/common.d.ts
+declare abstract class GelColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+  dialect: 'gel';
+}> {
+  readonly table: GelTable;
+  static readonly [entityKind]: string;
+  constructor(table: GelTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+//#endregion
+export { GelColumn };
+//# sourceMappingURL=common.d.ts.map

@@ -0,0 +1,12 @@
+import { entityKind } from "../entity.js";
+import { Table, TableConfig as TableConfig$1 } from "../table.js";
+import { GelColumn } from "./columns/common.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/gel-core/table.d.ts
+type TableConfig = TableConfig$1<GelColumn>;
+declare class GelTable<T extends TableConfig = TableConfig> extends Table<T> {
+  static readonly [entityKind]: string;
+}
+//#endregion
+export { GelTable };
+//# sourceMappingURL=table.d.ts.map

@@ -0,0 +1,13 @@
+import { entityKind } from "../entity.js";
+import { BaseSQLiteDatabase } from "../sqlite-core/db.js";
+import { ResultSet } from "../../../../@libsql_core@0.17.0/node_modules/@libsql/core/lib-esm/api.js";
+import { BatchItem, BatchResponse } from "../batch.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/libsql/driver-core.d.ts
+declare class LibSQLDatabase<TSchema extends Record<string, unknown> = Record<string, never>> extends BaseSQLiteDatabase<'async', ResultSet, TSchema> {
+  static readonly [entityKind]: string;
+  batch<U extends BatchItem<'sqlite'>, T extends Readonly<[U, ...U[]]>>(batch: T): Promise<BatchResponse<T>>;
+}
+//#endregion
+export { LibSQLDatabase };
+//# sourceMappingURL=driver-core.d.ts.map

@@ -0,0 +1,15 @@
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/migrator.d.ts
+interface MigrationConfig {
+  migrationsFolder: string;
+  migrationsTable?: string;
+  migrationsSchema?: string;
+}
+interface MigrationMeta {
+  sql: string[];
+  folderMillis: number;
+  hash: string;
+  bps: boolean;
+}
+//#endregion
+export { MigrationConfig, MigrationMeta };
+//# sourceMappingURL=migrator.d.ts.map

@@ -0,0 +1,16 @@
+import { entityKind } from "../../entity.js";
+import { MySqlTable } from "../table.js";
+import { ColumnBuilderRuntimeConfig, ColumnDataType } from "../../column-builder.js";
+import { Column, ColumnBaseConfig } from "../../column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/mysql-core/columns/common.d.ts
+declare abstract class MySqlColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+  dialect: 'mysql';
+}> {
+  readonly table: MySqlTable;
+  static readonly [entityKind]: string;
+  constructor(table: MySqlTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+//#endregion
+export { MySqlColumn };
+//# sourceMappingURL=common.d.ts.map

@@ -0,0 +1,13 @@
+import { entityKind } from "../entity.js";
+import { Table, TableConfig as TableConfig$1 } from "../table.js";
+import { MySqlColumn } from "./columns/common.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/mysql-core/table.d.ts
+type TableConfig = TableConfig$1<MySqlColumn>;
+declare class MySqlTable<T extends TableConfig = TableConfig> extends Table<T> {
+  static readonly [entityKind]: string;
+  protected $columns: T['columns'];
+}
+//#endregion
+export { MySqlTable };
+//# sourceMappingURL=table.d.ts.map

@@ -0,0 +1,27 @@
+import { Table } from "./table.js";
+import { SQL } from "./sql/sql.js";
+import { AnyColumn, Column } from "./column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/operations.d.ts
+type RequiredKeyOnly<TKey extends string, T extends Column> = T extends AnyColumn<{
+  notNull: true;
+  hasDefault: false;
+}> ? TKey : never;
+type OptionalKeyOnly<TKey extends string, T extends Column, OverrideT extends boolean | undefined = false> = TKey extends RequiredKeyOnly<TKey, T> ? never : T extends {
+  _: {
+    generated: undefined;
+  };
+} ? (T extends {
+  _: {
+    identity: undefined;
+  };
+} ? TKey : T['_']['identity'] extends 'always' ? OverrideT extends true ? TKey : never : TKey) : never;
+type SelectedFieldsFlat<TColumn extends Column> = Record<string, TColumn | SQL | SQL.Aliased>;
+type SelectedFields<TColumn extends Column, TTable extends Table> = Record<string, SelectedFieldsFlat<TColumn>[string] | TTable | SelectedFieldsFlat<TColumn>>;
+type SelectedFieldsOrdered<TColumn extends Column> = {
+  path: string[];
+  field: TColumn | SQL | SQL.Aliased;
+}[];
+//#endregion
+export { OptionalKeyOnly, RequiredKeyOnly, SelectedFields, SelectedFieldsFlat, SelectedFieldsOrdered };
+//# sourceMappingURL=operations.d.ts.map

@@ -0,0 +1,16 @@
+import { entityKind } from "../../entity.js";
+import { PgTable } from "../table.js";
+import { ColumnBuilderRuntimeConfig, ColumnDataType } from "../../column-builder.js";
+import { Column, ColumnBaseConfig } from "../../column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/pg-core/columns/common.d.ts
+declare abstract class PgColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+  dialect: 'pg';
+}> {
+  readonly table: PgTable;
+  static readonly [entityKind]: string;
+  constructor(table: PgTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+//#endregion
+export { PgColumn };
+//# sourceMappingURL=common.d.ts.map

@@ -0,0 +1,12 @@
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/pg-core/sequence.d.ts
+type PgSequenceOptions = {
+  increment?: number | string;
+  minValue?: number | string;
+  maxValue?: number | string;
+  startWith?: number | string;
+  cache?: number | string;
+  cycle?: boolean;
+};
+//#endregion
+export { PgSequenceOptions };
+//# sourceMappingURL=sequence.d.ts.map

@@ -0,0 +1,12 @@
+import { entityKind } from "../entity.js";
+import { Table, TableConfig as TableConfig$1 } from "../table.js";
+import { PgColumn } from "./columns/common.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/pg-core/table.d.ts
+type TableConfig = TableConfig$1<PgColumn>;
+declare class PgTable<T extends TableConfig = TableConfig> extends Table<T> {
+  static readonly [entityKind]: string;
+}
+//#endregion
+export { PgTable };
+//# sourceMappingURL=table.d.ts.map

@@ -0,0 +1,16 @@
+import { entityKind } from "../entity.js";
+import { SQL, SQLWrapper } from "../sql/sql.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/query-builders/query-builder.d.ts
+declare abstract class TypedQueryBuilder<TSelection, TResult = unknown, TConfig = unknown> implements SQLWrapper {
+  static readonly [entityKind]: string;
+  _: {
+    selectedFields: TSelection;
+    result: TResult;
+    config?: TConfig;
+  };
+  abstract getSQL(): SQL;
+}
+//#endregion
+export { TypedQueryBuilder };
+//# sourceMappingURL=query-builder.d.ts.map

@@ -0,0 +1,38 @@
+import { Table } from "../table.js";
+import { SelectedFields } from "../operations.js";
+import { Subquery } from "../subquery.js";
+import { ColumnsSelection, SQL, View } from "../sql/sql.js";
+import { Assume, DrizzleTypeError, Equal, IsAny, Simplify } from "../utils.js";
+import { ChangeColumnTableName, ColumnDataType, Dialect } from "../column-builder.js";
+import { AnyColumn, Column, ColumnBaseConfig, GetColumnData, UpdateColConfig } from "../column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/query-builders/select.types.d.ts
+type JoinType = 'inner' | 'left' | 'right' | 'full' | 'cross';
+type JoinNullability = 'nullable' | 'not-null';
+type ApplyNullability<T, TNullability extends JoinNullability> = TNullability extends 'nullable' ? T | null : TNullability extends 'null' ? null : T;
+type ApplyNullabilityToColumn<TColumn extends Column, TNullability extends JoinNullability> = TNullability extends 'not-null' ? TColumn : Column<Assume<UpdateColConfig<TColumn['_'], {
+  notNull: TNullability extends 'nullable' ? false : TColumn['_']['notNull'];
+}>, ColumnBaseConfig<ColumnDataType, string>>>;
+type ApplyNotNullMapToJoins<TResult, TNullabilityMap extends Record<string, JoinNullability>> = { [TTableName in keyof TResult & keyof TNullabilityMap & string]: ApplyNullability<TResult[TTableName], TNullabilityMap[TTableName]> } & {};
+type SelectMode = 'partial' | 'single' | 'multiple';
+type SelectResult<TResult, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability>> = TSelectMode extends 'partial' ? SelectPartialResult<TResult, TNullabilityMap> : TSelectMode extends 'single' ? SelectResultFields<TResult> : ApplyNotNullMapToJoins<SelectResultFields<TResult>, TNullabilityMap>;
+type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false : true;
+type Not<T extends boolean> = T extends true ? false : true;
+type SelectPartialResult<TFields, TNullability extends Record<string, JoinNullability>> = TNullability extends TNullability ? { [Key in keyof TFields]: TFields[Key] extends infer TField ? TField extends Table ? TField['_']['name'] extends keyof TNullability ? ApplyNullability<SelectResultFields<TField['_']['columns']>, TNullability[TField['_']['name']]> : never : TField extends Column ? TField['_']['tableName'] extends keyof TNullability ? ApplyNullability<SelectResultField<TField>, TNullability[TField['_']['tableName']]> : never : TField extends SQL | SQL.Aliased ? SelectResultField<TField> : TField extends Record<string, any> ? TField[keyof TField] extends AnyColumn<{
+  tableName: infer TTableName extends string;
+}> | SQL | SQL.Aliased ? Not<IsUnion<TTableName>> extends true ? ApplyNullability<SelectResultFields<TField>, TNullability[TTableName]> : SelectPartialResult<TField, TNullability> : never : never : never } : never;
+type MapColumnsToTableAlias<TColumns extends ColumnsSelection, TAlias extends string, TDialect extends Dialect> = { [Key in keyof TColumns]: TColumns[Key] extends Column ? ChangeColumnTableName<Assume<TColumns[Key], Column>, TAlias, TDialect> : TColumns[Key] } & {};
+type AddAliasToSelection<TSelection extends ColumnsSelection, TAlias extends string, TDialect extends Dialect> = Simplify<IsAny<TSelection> extends true ? any : { [Key in keyof TSelection]: TSelection[Key] extends Column ? ChangeColumnTableName<TSelection[Key], TAlias, TDialect> : TSelection[Key] extends Table ? AddAliasToSelection<TSelection[Key]['_']['columns'], TAlias, TDialect> : TSelection[Key] extends SQL | SQL.Aliased ? TSelection[Key] : TSelection[Key] extends ColumnsSelection ? MapColumnsToTableAlias<TSelection[Key], TAlias, TDialect> : never }>;
+type AppendToResult<TTableName extends string | undefined, TResult, TJoinedName extends string | undefined, TSelectedFields extends SelectedFields<Column, Table>, TOldSelectMode extends SelectMode> = TOldSelectMode extends 'partial' ? TResult : TOldSelectMode extends 'single' ? (TTableName extends string ? Record<TTableName, TResult> : TResult) & (TJoinedName extends string ? Record<TJoinedName, TSelectedFields> : TSelectedFields) : TResult & (TJoinedName extends string ? Record<TJoinedName, TSelectedFields> : TSelectedFields);
+type BuildSubquerySelection<TSelection extends ColumnsSelection, TNullability extends Record<string, JoinNullability>> = TSelection extends never ? any : { [Key in keyof TSelection]: TSelection[Key] extends SQL ? DrizzleTypeError<'You cannot reference this field without assigning it an alias first - use `.as(<alias>)`'> : TSelection[Key] extends SQL.Aliased ? TSelection[Key] : TSelection[Key] extends Table ? BuildSubquerySelection<TSelection[Key]['_']['columns'], TNullability> : TSelection[Key] extends Column ? ApplyNullabilityToColumn<TSelection[Key], TNullability[TSelection[Key]['_']['tableName']]> : TSelection[Key] extends ColumnsSelection ? BuildSubquerySelection<TSelection[Key], TNullability> : never } & {};
+type SetJoinsNullability<TNullabilityMap extends Record<string, JoinNullability>, TValue extends JoinNullability> = { [Key in keyof TNullabilityMap]: TValue };
+type AppendToNullabilityMap<TJoinsNotNull extends Record<string, JoinNullability>, TJoinedName extends string | undefined, TJoinType extends JoinType> = TJoinedName extends string ? 'left' extends TJoinType ? TJoinsNotNull & { [name in TJoinedName]: 'nullable' } : 'right' extends TJoinType ? SetJoinsNullability<TJoinsNotNull, 'nullable'> & { [name in TJoinedName]: 'not-null' } : 'inner' extends TJoinType ? TJoinsNotNull & { [name in TJoinedName]: 'not-null' } : 'cross' extends TJoinType ? TJoinsNotNull & { [name in TJoinedName]: 'not-null' } : 'full' extends TJoinType ? SetJoinsNullability<TJoinsNotNull, 'nullable'> & { [name in TJoinedName]: 'nullable' } : never : TJoinsNotNull;
+type TableLike = Table | Subquery | View | SQL;
+type GetSelectTableName<TTable extends TableLike> = TTable extends Table ? TTable['_']['name'] : TTable extends Subquery ? TTable['_']['alias'] : TTable extends View ? TTable['_']['name'] : TTable extends SQL ? undefined : never;
+type GetSelectTableSelection<TTable extends TableLike> = TTable extends Table ? TTable['_']['columns'] : TTable extends Subquery | View ? Assume<TTable['_']['selectedFields'], ColumnsSelection> : TTable extends SQL ? {} : never;
+type SelectResultField<T, TDeep extends boolean = true> = T extends DrizzleTypeError<any> ? T : T extends Table ? Equal<TDeep, true> extends true ? SelectResultField<T['_']['columns'], false> : never : T extends Column<any> ? GetColumnData<T> : T extends SQL | SQL.Aliased ? T['_']['type'] : T extends Record<string, any> ? SelectResultFields<T, true> : never;
+type SelectResultFields<TSelectedFields, TDeep extends boolean = true> = Simplify<{ [Key in keyof TSelectedFields]: SelectResultField<TSelectedFields[Key], TDeep> }>;
+type SetOperator = 'union' | 'intersect' | 'except';
+//#endregion
+export { AddAliasToSelection, AppendToNullabilityMap, AppendToResult, BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, JoinType, SelectMode, SelectResult, SelectResultFields, SetOperator };
+//# sourceMappingURL=select.types.d.ts.map

@@ -0,0 +1,14 @@
+import { entityKind } from "./entity.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/query-promise.d.ts
+declare abstract class QueryPromise<T> implements Promise<T> {
+  static readonly [entityKind]: string;
+  [Symbol.toStringTag]: string;
+  catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+  finally(onFinally?: (() => void) | null | undefined): Promise<T>;
+  then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+  abstract execute(): Promise<T>;
+}
+//#endregion
+export { QueryPromise };
+//# sourceMappingURL=query-promise.d.ts.map

@@ -0,0 +1,171 @@
+import { entityKind } from "./entity.js";
+import { AnyTable, InferModelFromColumns, Table } from "./table.js";
+import { Placeholder, SQL, sql } from "./sql/sql.js";
+import { Assume, ColumnsWithTable, Equal, Simplify, ValueOrArray } from "./utils.js";
+import { BinaryOperator, and, between, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/conditions.js";
+import { asc, desc } from "./sql/expressions/select.js";
+import { AnyColumn, Column } from "./column.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/relations.d.ts
+declare abstract class Relation<TTableName extends string = string> {
+  readonly sourceTable: Table;
+  readonly referencedTable: AnyTable<{
+    name: TTableName;
+  }>;
+  readonly relationName: string | undefined;
+  static readonly [entityKind]: string;
+  readonly $brand: 'Relation';
+  readonly referencedTableName: TTableName;
+  fieldName: string;
+  constructor(sourceTable: Table, referencedTable: AnyTable<{
+    name: TTableName;
+  }>, relationName: string | undefined);
+  abstract withFieldName(fieldName: string): Relation<TTableName>;
+}
+declare class Relations<TTableName extends string = string, TConfig extends Record<string, Relation> = Record<string, Relation>> {
+  readonly table: AnyTable<{
+    name: TTableName;
+  }>;
+  readonly config: (helpers: TableRelationsHelpers<TTableName>) => TConfig;
+  static readonly [entityKind]: string;
+  readonly $brand: 'Relations';
+  constructor(table: AnyTable<{
+    name: TTableName;
+  }>, config: (helpers: TableRelationsHelpers<TTableName>) => TConfig);
+}
+declare class One<TTableName extends string = string, TIsNullable extends boolean = boolean> extends Relation<TTableName> {
+  readonly config: RelationConfig<TTableName, string, AnyColumn<{
+    tableName: TTableName;
+  }>[]> | undefined;
+  readonly isNullable: TIsNullable;
+  static readonly [entityKind]: string;
+  protected $relationBrand: 'One';
+  constructor(sourceTable: Table, referencedTable: AnyTable<{
+    name: TTableName;
+  }>, config: RelationConfig<TTableName, string, AnyColumn<{
+    tableName: TTableName;
+  }>[]> | undefined, isNullable: TIsNullable);
+  withFieldName(fieldName: string): One<TTableName>;
+}
+declare class Many<TTableName extends string> extends Relation<TTableName> {
+  readonly config: {
+    relationName: string;
+  } | undefined;
+  static readonly [entityKind]: string;
+  protected $relationBrand: 'Many';
+  constructor(sourceTable: Table, referencedTable: AnyTable<{
+    name: TTableName;
+  }>, config: {
+    relationName: string;
+  } | undefined);
+  withFieldName(fieldName: string): Many<TTableName>;
+}
+type TableRelationsKeysOnly<TSchema extends Record<string, unknown>, TTableName extends string, K extends keyof TSchema> = TSchema[K] extends Relations<TTableName> ? K : never;
+type ExtractTableRelationsFromSchema<TSchema extends Record<string, unknown>, TTableName extends string> = ExtractObjectValues<{ [K in keyof TSchema as TableRelationsKeysOnly<TSchema, TTableName, K>]: TSchema[K] extends Relations<TTableName, infer TConfig> ? TConfig : never }>;
+type ExtractObjectValues<T> = T[keyof T];
+declare function getOperators(): {
+  and: typeof and;
+  between: typeof between;
+  eq: BinaryOperator;
+  exists: typeof exists;
+  gt: BinaryOperator;
+  gte: BinaryOperator;
+  ilike: typeof ilike;
+  inArray: typeof inArray;
+  isNull: typeof isNull;
+  isNotNull: typeof isNotNull;
+  like: typeof like;
+  lt: BinaryOperator;
+  lte: BinaryOperator;
+  ne: BinaryOperator;
+  not: typeof not;
+  notBetween: typeof notBetween;
+  notExists: typeof notExists;
+  notLike: typeof notLike;
+  notIlike: typeof notIlike;
+  notInArray: typeof notInArray;
+  or: typeof or;
+  sql: typeof sql;
+};
+type Operators = ReturnType<typeof getOperators>;
+declare function getOrderByOperators(): {
+  sql: typeof sql;
+  asc: typeof asc;
+  desc: typeof desc;
+};
+type OrderByOperators = ReturnType<typeof getOrderByOperators>;
+type FindTableByDBName<TSchema extends TablesRelationalConfig, TTableName extends string> = ExtractObjectValues<{ [K in keyof TSchema as TSchema[K]['dbName'] extends TTableName ? K : never]: TSchema[K] }>;
+type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TIsRoot extends boolean = boolean, TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig> = {
+  columns?: { [K in keyof TTableConfig['columns']]?: boolean } | undefined;
+  with?: { [K in keyof TTableConfig['relations']]?: true | DBQueryConfig<TTableConfig['relations'][K] extends One ? 'one' : 'many', false, TSchema, FindTableByDBName<TSchema, TTableConfig['relations'][K]['referencedTableName']>> | undefined } | undefined;
+  extras?: Record<string, SQL.Aliased> | ((fields: Simplify<[TTableConfig['columns']] extends [never] ? {} : TTableConfig['columns']>, operators: {
+    sql: Operators['sql'];
+  }) => Record<string, SQL.Aliased>) | undefined;
+} & (TRelationType extends 'many' ? {
+  where?: SQL | undefined | ((fields: Simplify<[TTableConfig['columns']] extends [never] ? {} : TTableConfig['columns']>, operators: Operators) => SQL | undefined);
+  orderBy?: ValueOrArray<AnyColumn | SQL> | ((fields: Simplify<[TTableConfig['columns']] extends [never] ? {} : TTableConfig['columns']>, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+  limit?: number | Placeholder | undefined;
+} & (TIsRoot extends true ? {
+  offset?: number | Placeholder | undefined;
+} : {}) : {});
+interface TableRelationalConfig {
+  tsName: string;
+  dbName: string;
+  columns: Record<string, Column>;
+  relations: Record<string, Relation>;
+  primaryKey: AnyColumn[];
+  schema?: string;
+}
+type TablesRelationalConfig = Record<string, TableRelationalConfig>;
+interface RelationalSchemaConfig<TSchema extends TablesRelationalConfig> {
+  fullSchema: Record<string, unknown>;
+  schema: TSchema;
+  tableNamesMap: Record<string, string>;
+}
+type ExtractTablesWithRelations<TSchema extends Record<string, unknown>> = { [K in keyof TSchema as TSchema[K] extends Table ? K : never]: TSchema[K] extends Table ? {
+  tsName: K & string;
+  dbName: TSchema[K]['_']['name'];
+  columns: TSchema[K]['_']['columns'];
+  relations: ExtractTableRelationsFromSchema<TSchema, TSchema[K]['_']['name']>;
+  primaryKey: AnyColumn[];
+} : never };
+type ReturnTypeOrValue<T> = T extends ((...args: any[]) => infer R) ? R : T;
+type BuildRelationResult<TSchema extends TablesRelationalConfig, TInclude, TRelations extends Record<string, Relation>> = { [K in NonUndefinedKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<TSchema, FindTableByDBName<TSchema, TRel['referencedTableName']>, Assume<TInclude[K], true | Record<string, unknown>>> extends infer TResult ? TRel extends One ? TResult | (Equal<TRel['isNullable'], false> extends true ? null : never) : TResult[] : never : never };
+type NonUndefinedKeysOnly<T> = ExtractObjectValues<{ [K in keyof T as T[K] extends undefined ? never : K]: K }> & keyof T;
+type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>> = Equal<TFullSelection, true> extends true ? InferModelFromColumns<TTableConfig['columns']> : TFullSelection extends Record<string, unknown> ? Simplify<(TFullSelection['columns'] extends Record<string, unknown> ? InferModelFromColumns<{ [K in Equal<Exclude<TFullSelection['columns'][keyof TFullSelection['columns'] & keyof TTableConfig['columns']], undefined>, false> extends true ? Exclude<keyof TTableConfig['columns'], NonUndefinedKeysOnly<TFullSelection['columns']>> : { [K in keyof TFullSelection['columns']]: Equal<TFullSelection['columns'][K], true> extends true ? K : never }[keyof TFullSelection['columns']] & keyof TTableConfig['columns']]: TTableConfig['columns'][K] }> : InferModelFromColumns<TTableConfig['columns']>) & (TFullSelection['extras'] extends Record<string, unknown> | ((...args: any[]) => Record<string, unknown>) ? { [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: Assume<ReturnTypeOrValue<TFullSelection['extras']>[K], SQL.Aliased>['_']['type'] } : {}) & (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<TSchema, TFullSelection['with'], TTableConfig['relations']> : {})> : never;
+interface RelationConfig<TTableName extends string, TForeignTableName extends string, TColumns extends AnyColumn<{
+  tableName: TTableName;
+}>[]> {
+  relationName?: string;
+  fields: TColumns;
+  references: ColumnsWithTable<TTableName, TForeignTableName, TColumns>;
+}
+declare function createTableRelationsHelpers<TTableName extends string>(sourceTable: AnyTable<{
+  name: TTableName;
+}>): {
+  one: <TForeignTable extends Table, TColumns extends [AnyColumn<{
+    tableName: TTableName;
+  }>, ...AnyColumn<{
+    tableName: TTableName;
+  }>[]]>(table: TForeignTable, config?: RelationConfig<TTableName, TForeignTable["_"]["name"], TColumns> | undefined) => One<TForeignTable["_"]["name"], Equal<TColumns[number]["_"]["notNull"], true>>;
+  many: <TForeignTable extends Table>(referencedTable: TForeignTable, config?: {
+    relationName: string;
+  }) => Many<TForeignTable["_"]["name"]>;
+};
+type TableRelationsHelpers<TTableName extends string> = ReturnType<typeof createTableRelationsHelpers<TTableName>>;
+interface BuildRelationalQueryResult<TTable extends Table = Table, TColumn extends Column = Column> {
+  tableTsKey: string;
+  selection: {
+    dbKey: string;
+    tsKey: string;
+    field: TColumn | SQL | SQL.Aliased;
+    relationTableTsKey: string | undefined;
+    isJson: boolean;
+    isExtra?: boolean;
+    selection: BuildRelationalQueryResult<TTable>['selection'];
+  }[];
+  sql: TTable | SQL;
+}
+//#endregion
+export { BuildQueryResult, BuildRelationalQueryResult, DBQueryConfig, ExtractTablesWithRelations, Relation, RelationalSchemaConfig, TableRelationalConfig, TablesRelationalConfig };
+//# sourceMappingURL=relations.d.ts.map

@@ -0,0 +1,12 @@
+import { Dialect } from "./column-builder.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql+client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/runnable-query.d.ts
+interface RunnableQuery<T, TDialect extends Dialect> {
+  readonly _: {
+    readonly dialect: TDialect;
+    readonly result: T;
+  };
+}
+//#endregion
+export { RunnableQuery };
+//# sourceMappingURL=runnable-query.d.ts.map