npm - @m5kdev/web-ui - Versions diffs - 0.8.0 → 0.8.2 - Mend

@m5kdev/web-ui 0.8.0 → 0.8.2

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 (536) 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/session.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { Query } 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/session.d.ts
+interface PreparedQuery {
+  getQuery(): Query;
+  mapResult(response: unknown, isFromBatch?: boolean): unknown;
+}
+//#endregion
+export { PreparedQuery };
+//# sourceMappingURL=session.d.ts.map

@@ -0,0 +1,16 @@
+import { entityKind } from "../../entity.js";
+import { SingleStoreTable } 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/singlestore-core/columns/common.d.ts
+declare abstract class SingleStoreColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+  dialect: 'singlestore';
+}> {
+  readonly table: SingleStoreTable;
+  static readonly [entityKind]: string;
+  constructor(table: SingleStoreTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+//#endregion
+export { SingleStoreColumn };
+//# sourceMappingURL=common.d.ts.map

@@ -0,0 +1,13 @@
+import { entityKind } from "../entity.js";
+import { Table, TableConfig as TableConfig$1 } from "../table.js";
+import { SingleStoreColumn } 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/singlestore-core/table.d.ts
+type TableConfig = TableConfig$1<SingleStoreColumn>;
+declare class SingleStoreTable<T extends TableConfig = TableConfig> extends Table<T> {
+  static readonly [entityKind]: string;
+  protected $columns: T['columns'];
+}
+//#endregion
+export { SingleStoreTable };
+//# sourceMappingURL=table.d.ts.map

@@ -0,0 +1,287 @@
+import { Placeholder, SQL, SQLWrapper } from "../sql.js";
+import { AnyColumn, Column, GetColumnData } 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/sql/expressions/conditions.d.ts
+interface BinaryOperator {
+  <TColumn extends Column>(left: TColumn, right: GetColumnData<TColumn, 'raw'> | SQLWrapper): SQL;
+  <T>(left: SQL.Aliased<T>, right: T | SQLWrapper): SQL;
+  <T extends SQLWrapper>(left: Exclude<T, SQL.Aliased | Column>, right: unknown): SQL;
+}
+/**
+ * Combine a list of conditions with the `and` operator. Conditions
+ * that are equal `undefined` are automatically ignored.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * db.select().from(cars)
+ *   .where(
+ *     and(
+ *       eq(cars.make, 'Volvo'),
+ *       eq(cars.year, 1950),
+ *     )
+ *   )
+ * ```
+ */
+declare function and(...conditions: (SQLWrapper | undefined)[]): SQL | undefined;
+/**
+ * Combine a list of conditions with the `or` operator. Conditions
+ * that are equal `undefined` are automatically ignored.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * db.select().from(cars)
+ *   .where(
+ *     or(
+ *       eq(cars.make, 'GM'),
+ *       eq(cars.make, 'Ford'),
+ *     )
+ *   )
+ * ```
+ */
+declare function or(...conditions: (SQLWrapper | undefined)[]): SQL | undefined;
+/**
+ * Negate the meaning of an expression using the `not` keyword.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars _not_ made by GM or Ford.
+ * db.select().from(cars)
+ *   .where(not(inArray(cars.make, ['GM', 'Ford'])))
+ * ```
+ */
+declare function not(condition: SQLWrapper): SQL;
+/**
+ * Test whether the first parameter, a column or expression,
+ * has a value from a list passed as the second argument.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made by Ford or GM.
+ * db.select().from(cars)
+ *   .where(inArray(cars.make, ['Ford', 'GM']))
+ * ```
+ *
+ * @see notInArray for the inverse of this test
+ */
+declare function inArray<T>(column: SQL.Aliased<T>, values: (T | Placeholder)[] | SQLWrapper): SQL;
+declare function inArray<TColumn extends Column>(column: TColumn, values: ReadonlyArray<GetColumnData<TColumn, 'raw'> | Placeholder> | SQLWrapper): SQL;
+declare function inArray<T extends SQLWrapper>(column: Exclude<T, SQL.Aliased | Column>, values: ReadonlyArray<unknown | Placeholder> | SQLWrapper): SQL;
+/**
+ * Test whether the first parameter, a column or expression,
+ * has a value that is not present in a list passed as the
+ * second argument.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made by any company except Ford or GM.
+ * db.select().from(cars)
+ *   .where(notInArray(cars.make, ['Ford', 'GM']))
+ * ```
+ *
+ * @see inArray for the inverse of this test
+ */
+declare function notInArray<T>(column: SQL.Aliased<T>, values: (T | Placeholder)[] | SQLWrapper): SQL;
+declare function notInArray<TColumn extends Column>(column: TColumn, values: (GetColumnData<TColumn, 'raw'> | Placeholder)[] | SQLWrapper): SQL;
+declare function notInArray<T extends SQLWrapper>(column: Exclude<T, SQL.Aliased | Column>, values: (unknown | Placeholder)[] | SQLWrapper): SQL;
+/**
+ * Test whether an expression is NULL. By the SQL standard,
+ * NULL is neither equal nor not equal to itself, so
+ * it's recommended to use `isNull` and `notIsNull` for
+ * comparisons to NULL.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars that have no discontinuedAt date.
+ * db.select().from(cars)
+ *   .where(isNull(cars.discontinuedAt))
+ * ```
+ *
+ * @see isNotNull for the inverse of this test
+ */
+declare function isNull(value: SQLWrapper): SQL;
+/**
+ * Test whether an expression is not NULL. By the SQL standard,
+ * NULL is neither equal nor not equal to itself, so
+ * it's recommended to use `isNull` and `notIsNull` for
+ * comparisons to NULL.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars that have been discontinued.
+ * db.select().from(cars)
+ *   .where(isNotNull(cars.discontinuedAt))
+ * ```
+ *
+ * @see isNull for the inverse of this test
+ */
+declare function isNotNull(value: SQLWrapper): SQL;
+/**
+ * Test whether a subquery evaluates to have any rows.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Users whose `homeCity` column has a match in a cities
+ * // table.
+ * db
+ *   .select()
+ *   .from(users)
+ *   .where(
+ *     exists(db.select()
+ *       .from(cities)
+ *       .where(eq(users.homeCity, cities.id))),
+ *   );
+ * ```
+ *
+ * @see notExists for the inverse of this test
+ */
+declare function exists(subquery: SQLWrapper): SQL;
+/**
+ * Test whether a subquery doesn't include any result
+ * rows.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Users whose `homeCity` column doesn't match
+ * // a row in the cities table.
+ * db
+ *   .select()
+ *   .from(users)
+ *   .where(
+ *     notExists(db.select()
+ *       .from(cities)
+ *       .where(eq(users.homeCity, cities.id))),
+ *   );
+ * ```
+ *
+ * @see exists for the inverse of this test
+ */
+declare function notExists(subquery: SQLWrapper): SQL;
+/**
+ * Test whether an expression is between two values. This
+ * is an easier way to express range tests, which would be
+ * expressed mathematically as `x <= a <= y` but in SQL
+ * would have to be like `a >= x AND a <= y`.
+ *
+ * Between is inclusive of the endpoints: if `column`
+ * is equal to `min` or `max`, it will be TRUE.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made between 1990 and 2000
+ * db.select().from(cars)
+ *   .where(between(cars.year, 1990, 2000))
+ * ```
+ *
+ * @see notBetween for the inverse of this test
+ */
+declare function between<T>(column: SQL.Aliased, min: T | SQLWrapper, max: T | SQLWrapper): SQL;
+declare function between<TColumn extends AnyColumn>(column: TColumn, min: GetColumnData<TColumn, 'raw'> | SQLWrapper, max: GetColumnData<TColumn, 'raw'> | SQLWrapper): SQL;
+declare function between<T extends SQLWrapper>(column: Exclude<T, SQL.Aliased | Column>, min: unknown, max: unknown): SQL;
+/**
+ * Test whether an expression is not between two values.
+ *
+ * This, like `between`, includes its endpoints, so if
+ * the `column` is equal to `min` or `max`, in this case
+ * it will evaluate to FALSE.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Exclude cars made in the 1970s
+ * db.select().from(cars)
+ *   .where(notBetween(cars.year, 1970, 1979))
+ * ```
+ *
+ * @see between for the inverse of this test
+ */
+declare function notBetween<T>(column: SQL.Aliased, min: T | SQLWrapper, max: T | SQLWrapper): SQL;
+declare function notBetween<TColumn extends AnyColumn>(column: TColumn, min: GetColumnData<TColumn, 'raw'> | SQLWrapper, max: GetColumnData<TColumn, 'raw'> | SQLWrapper): SQL;
+declare function notBetween<T extends SQLWrapper>(column: Exclude<T, SQL.Aliased | Column>, min: unknown, max: unknown): SQL;
+/**
+ * Compare a column to a pattern, which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select all cars with 'Turbo' in their names.
+ * db.select().from(cars)
+ *   .where(like(cars.name, '%Turbo%'))
+ * ```
+ *
+ * @see ilike for a case-insensitive version of this condition
+ */
+declare function like(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL;
+/**
+ * The inverse of like - this tests that a given column
+ * does not match a pattern, which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select all cars that don't have "ROver" in their name.
+ * db.select().from(cars)
+ *   .where(notLike(cars.name, '%Rover%'))
+ * ```
+ *
+ * @see like for the inverse condition
+ * @see notIlike for a case-insensitive version of this condition
+ */
+declare function notLike(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL;
+/**
+ * Case-insensitively compare a column to a pattern,
+ * which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
+ *
+ * Unlike like, this performs a case-insensitive comparison.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select all cars with 'Turbo' in their names.
+ * db.select().from(cars)
+ *   .where(ilike(cars.name, '%Turbo%'))
+ * ```
+ *
+ * @see like for a case-sensitive version of this condition
+ */
+declare function ilike(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL;
+/**
+ * The inverse of ilike - this case-insensitively tests that a given column
+ * does not match a pattern, which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select all cars that don't have "Rover" in their name.
+ * db.select().from(cars)
+ *   .where(notLike(cars.name, '%Rover%'))
+ * ```
+ *
+ * @see ilike for the inverse condition
+ * @see notLike for a case-sensitive version of this condition
+ */
+declare function notIlike(column: Column | SQL.Aliased | SQL, value: string | SQLWrapper): SQL;
+//#endregion
+export { BinaryOperator, and, between, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or };
+//# sourceMappingURL=conditions.d.ts.map

@@ -0,0 +1,43 @@
+import { SQL, SQLWrapper } from "../sql.js";
+import { AnyColumn } 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/sql/expressions/select.d.ts
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in ascending
+ * order. By the SQL standard, ascending order is the
+ * default, so it is not usually necessary to specify
+ * ascending sort order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Return cars, starting with the oldest models
+ * // and going in ascending order to the newest.
+ * db.select().from(cars)
+ *   .orderBy(asc(cars.year));
+ * ```
+ *
+ * @see desc to sort in descending order
+ */
+declare function asc(column: AnyColumn | SQLWrapper): SQL;
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in descending
+ * order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select users, with the most recently created
+ * // records coming first.
+ * db.select().from(users)
+ *   .orderBy(desc(users.createdAt));
+ * ```
+ *
+ * @see asc to sort in ascending order
+ */
+declare function desc(column: AnyColumn | SQLWrapper): SQL;
+//#endregion
+export { asc, desc };
+//# sourceMappingURL=select.d.ts.map

@@ -0,0 +1,225 @@
+import { entityKind } from "../entity.js";
+import { CasingCache } from "../casing.js";
+import { Table } from "../table.js";
+import { Subquery } from "../subquery.js";
+import { SelectResult } from "../query-builders/select.types.js";
+import { Assume, Equal } from "../utils.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/sql/sql.d.ts
+/**
+ * This class is used to indicate a primitive param value that is used in `sql` tag.
+ * It is only used on type level and is never instantiated at runtime.
+ * If you see a value of this type in the code, its runtime value is actually the primitive param value.
+ */
+declare class FakePrimitiveParam {
+  static readonly [entityKind]: string;
+}
+interface BuildQueryConfig {
+  casing: CasingCache;
+  escapeName(name: string): string;
+  escapeParam(num: number, value: unknown): string;
+  escapeString(str: string): string;
+  prepareTyping?: (encoder: DriverValueEncoder<unknown, unknown>) => QueryTypingsValue;
+  paramStartIndex?: {
+    value: number;
+  };
+  inlineParams?: boolean;
+  invokeSource?: 'indexes' | undefined;
+}
+type QueryTypingsValue = 'json' | 'decimal' | 'time' | 'timestamp' | 'uuid' | 'date' | 'none';
+interface Query {
+  sql: string;
+  params: unknown[];
+}
+interface QueryWithTypings extends Query {
+  typings?: QueryTypingsValue[];
+}
+/**
+ * Any value that implements the `getSQL` method. The implementations include:
+ * - `Table`
+ * - `Column`
+ * - `View`
+ * - `Subquery`
+ * - `SQL`
+ * - `SQL.Aliased`
+ * - `Placeholder`
+ * - `Param`
+ */
+interface SQLWrapper {
+  getSQL(): SQL;
+  shouldOmitSQLParens?(): boolean;
+}
+declare class StringChunk implements SQLWrapper {
+  static readonly [entityKind]: string;
+  readonly value: string[];
+  constructor(value: string | string[]);
+  getSQL(): SQL<unknown>;
+}
+declare class SQL<T = unknown> implements SQLWrapper {
+  readonly queryChunks: SQLChunk[];
+  static readonly [entityKind]: string;
+  _: {
+    brand: 'SQL';
+    type: T;
+  };
+  private shouldInlineParams;
+  constructor(queryChunks: SQLChunk[]);
+  append(query: SQL): this;
+  toQuery(config: BuildQueryConfig): QueryWithTypings;
+  buildQueryFromSourceParams(chunks: SQLChunk[], _config: BuildQueryConfig): Query;
+  private mapInlineParam;
+  getSQL(): SQL;
+  as(alias: string): SQL.Aliased<T>;
+  /**
+   * @deprecated
+   * Use ``sql<DataType>`query`.as(alias)`` instead.
+   */
+  as<TData>(): SQL<TData>;
+  /**
+   * @deprecated
+   * Use ``sql<DataType>`query`.as(alias)`` instead.
+   */
+  as<TData>(alias: string): SQL.Aliased<TData>;
+  mapWith<TDecoder extends DriverValueDecoder<any, any> | DriverValueDecoder<any, any>['mapFromDriverValue']>(decoder: TDecoder): SQL<GetDecoderResult<TDecoder>>;
+  inlineParams(): this;
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(condition: any | undefined): this | undefined;
+}
+type GetDecoderResult<T> = T extends Column ? T['_']['data'] : T extends DriverValueDecoder<infer TData, any> | DriverValueDecoder<infer TData, any>['mapFromDriverValue'] ? TData : never;
+/**
+ * Any DB name (table, column, index etc.)
+ */
+declare class Name implements SQLWrapper {
+  readonly value: string;
+  static readonly [entityKind]: string;
+  protected brand: 'Name';
+  constructor(value: string);
+  getSQL(): SQL<unknown>;
+}
+/**
+ * Any DB name (table, column, index etc.)
+ * @deprecated Use `sql.identifier` instead.
+ */
+declare function name(value: string): Name;
+interface DriverValueDecoder<TData, TDriverParam> {
+  mapFromDriverValue(value: TDriverParam): TData;
+}
+interface DriverValueEncoder<TData, TDriverParam> {
+  mapToDriverValue(value: TData): TDriverParam | SQL;
+}
+interface DriverValueMapper<TData, TDriverParam> extends DriverValueDecoder<TData, TDriverParam>, DriverValueEncoder<TData, TDriverParam> {}
+/** Parameter value that is optionally bound to an encoder (for example, a column). */
+declare class Param<TDataType = unknown, TDriverParamType = TDataType> implements SQLWrapper {
+  readonly value: TDataType;
+  readonly encoder: DriverValueEncoder<TDataType, TDriverParamType>;
+  static readonly [entityKind]: string;
+  protected brand: 'BoundParamValue';
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(value: TDataType, encoder?: DriverValueEncoder<TDataType, TDriverParamType>);
+  getSQL(): SQL<unknown>;
+}
+/**
+ * Anything that can be passed to the `` sql`...` `` tagged function.
+ */
+type SQLChunk = StringChunk | SQLChunk[] | SQLWrapper | SQL | Table | View | Subquery | AnyColumn | Param | Name | undefined | FakePrimitiveParam | Placeholder;
+declare function sql<T>(strings: TemplateStringsArray, ...params: any[]): SQL<T>;
+declare namespace sql {
+  function empty(): SQL;
+  /** @deprecated - use `sql.join()` */
+  function fromList(list: SQLChunk[]): SQL;
+  /**
+   * Convenience function to create an SQL query from a raw string.
+   * @param str The raw SQL query string.
+   */
+  function raw(str: string): SQL;
+  /**
+   * Join a list of SQL chunks with a separator.
+   * @example
+   * ```ts
+   * const query = sql.join([sql`a`, sql`b`, sql`c`]);
+   * // sql`abc`
+   * ```
+   * @example
+   * ```ts
+   * const query = sql.join([sql`a`, sql`b`, sql`c`], sql`, `);
+   * // sql`a, b, c`
+   * ```
+   */
+  function join(chunks: SQLChunk[], separator?: SQLChunk): SQL;
+  /**
+   * Create a SQL chunk that represents a DB identifier (table, column, index etc.).
+   * When used in a query, the identifier will be escaped based on the DB engine.
+   * For example, in PostgreSQL, identifiers are escaped with double quotes.
+   *
+   * **WARNING: This function does not offer any protection against SQL injections, so you must validate any user input beforehand.**
+   *
+   * @example ```ts
+   * const query = sql`SELECT * FROM ${sql.identifier('my-table')}`;
+   * // 'SELECT * FROM "my-table"'
+   * ```
+   */
+  function identifier(value: string): Name;
+  function placeholder<TName extends string>(name: TName): Placeholder<TName>;
+  function param<TData, TDriver>(value: TData, encoder?: DriverValueEncoder<TData, TDriver>): Param<TData, TDriver>;
+}
+declare namespace SQL {
+  class Aliased<T = unknown> implements SQLWrapper {
+    readonly sql: SQL;
+    readonly fieldAlias: string;
+    static readonly [entityKind]: string;
+    _: {
+      brand: 'SQL.Aliased';
+      type: T;
+    };
+    constructor(sql: SQL, fieldAlias: string);
+    getSQL(): SQL;
+  }
+}
+declare class Placeholder<TName extends string = string, TValue = any> implements SQLWrapper {
+  readonly name: TName;
+  static readonly [entityKind]: string;
+  protected: TValue;
+  constructor(name: TName);
+  getSQL(): SQL;
+}
+type ColumnsSelection = Record<string, unknown>;
+declare abstract class View<TName extends string = string, TExisting extends boolean = boolean, TSelection extends ColumnsSelection = ColumnsSelection> implements SQLWrapper {
+  static readonly [entityKind]: string;
+  _: {
+    brand: 'View';
+    viewBrand: string;
+    name: TName;
+    existing: TExisting;
+    selectedFields: TSelection;
+  };
+  readonly $inferSelect: InferSelectViewModel<View<Assume<TName, string>, TExisting, TSelection>>;
+  constructor({
+    name,
+    schema,
+    selectedFields,
+    query
+  }: {
+    name: TName;
+    schema: string | undefined;
+    selectedFields: ColumnsSelection;
+    query: SQL | undefined;
+  });
+  getSQL(): SQL<unknown>;
+}
+type InferSelectViewModel<TView extends View> = Equal<TView['_']['selectedFields'], {
+  [x: string]: unknown;
+}> extends true ? {
+  [x: string]: unknown;
+} : SelectResult<TView['_']['selectedFields'], 'single', Record<TView['_']['name'], 'not-null'>>;
+//#endregion
+export { ColumnsSelection, DriverValueMapper, Param, Placeholder, Query, QueryTypingsValue, QueryWithTypings, SQL, SQLWrapper, View, sql };
+//# sourceMappingURL=sql.d.ts.map

@@ -0,0 +1,18 @@
+import { entityKind } from "../../entity.js";
+import { Update } from "../../utils.js";
+import { SQLiteTable } 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/sqlite-core/columns/common.d.ts
+declare abstract class SQLiteColumn<T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>, TRuntimeConfig extends object = {}, TTypeConfig extends object = {}> extends Column<T, TRuntimeConfig, TTypeConfig & {
+  dialect: 'sqlite';
+}> {
+  readonly table: SQLiteTable;
+  static readonly [entityKind]: string;
+  constructor(table: SQLiteTable, config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>);
+}
+type AnySQLiteColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = SQLiteColumn<Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>>;
+//#endregion
+export { AnySQLiteColumn, SQLiteColumn };
+//# sourceMappingURL=common.d.ts.map