drizzle-databend 0.1.11 → 0.1.13

package/dist/columns.d.ts

@@ -2,69 +2,57 @@
  * Databend VARIANT column type.
  * Stores semi-structured JSON-like data. Maps to `unknown` in TypeScript.
  */
-export declare const databendVariant: <TData = unknown>(name: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
+export declare const databendVariant: <TData = unknown>(name: string) => import("./databend-core/index.ts").DatabendCustomColumnBuilder<{
     data: TData;
-    driverParam: string | TData;
-    enumValues: undefined;
+    driverData: string | TData;
+    notNull: boolean;
+    default: boolean;
 }>;
 /**
  * Databend ARRAY column type.
  * Stores typed arrays. Maps to `T[]` in TypeScript.
  */
-export declare const databendArray: <TData = unknown>(name: string, elementType: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
+export declare const databendArray: <TData = unknown>(name: string, elementType: string) => import("./databend-core/index.ts").DatabendCustomColumnBuilder<{
     data: TData[];
-    driverParam: string | TData[];
-    enumValues: undefined;
+    driverData: TData[] | string;
+    notNull: boolean;
+    default: boolean;
 }>;
 /**
  * Databend TUPLE column type.
  * Stores positional tuples. Maps to typed tuple in TypeScript.
  */
-export declare const databendTuple: <TData extends unknown[]>(name: string, types: string[]) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
+export declare const databendTuple: <TData extends unknown[]>(name: string, types: string[]) => import("./databend-core/index.ts").DatabendCustomColumnBuilder<{
     data: TData;
-    driverParam: string | TData;
-    enumValues: undefined;
+    driverData: TData | string;
+    notNull: boolean;
+    default: boolean;
 }>;
 /**
  * Databend MAP column type.
  * Stores key-value maps. Maps to `Record<K, V>` in TypeScript.
  */
-export declare const databendMap: <TData extends Record<string, any>>(name: string, keyType: string, valueType: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
+export declare const databendMap: <TData extends Record<string, any>>(name: string, keyType: string, valueType: string) => import("./databend-core/index.ts").DatabendCustomColumnBuilder<{
     data: TData;
-    driverParam: string | TData;
-    enumValues: undefined;
+    driverData: TData | string;
+    notNull: boolean;
+    default: boolean;
 }>;
 /**
  * Databend TIMESTAMP column type.
  */
-export declare const databendTimestamp: (name: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
-    data: string | Date;
-    driverParam: string | Date;
-    enumValues: undefined;
+export declare const databendTimestamp: (name: string) => import("./databend-core/index.ts").DatabendCustomColumnBuilder<{
+    data: Date | string;
+    driverData: string | Date;
+    notNull: boolean;
+    default: boolean;
 }>;
 /**
  * Databend DATE column type.
  */
-export declare const databendDate: (name: string) => import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
+export declare const databendDate: (name: string) => import("./databend-core/index.ts").DatabendCustomColumnBuilder<{
     data: string | Date;
-    driverParam: string | Date;
-    enumValues: undefined;
+    driverData: string | Date;
+    notNull: boolean;
+    default: boolean;
 }>;

package/dist/databend-core/alias.d.ts

@@ -0,0 +1 @@
+export declare function alias(table: any, alias: string): any;

package/dist/databend-core/columns/all.d.ts

@@ -0,0 +1,35 @@
+import { bigint } from './bigint.ts';
+import { binary } from './binary.ts';
+import { bitmap } from './bitmap.ts';
+import { boolean } from './boolean.ts';
+import { customType } from './custom.ts';
+import { date } from './date.ts';
+import { decimal } from './decimal.ts';
+import { doublePrecision } from './double.ts';
+import { float, real } from './float.ts';
+import { integer } from './integer.ts';
+import { smallint } from './smallint.ts';
+import { text } from './text.ts';
+import { timestamp } from './timestamp.ts';
+import { tinyint } from './tinyint.ts';
+import { varchar } from './varchar.ts';
+import { variant } from './variant.ts';
+export declare function getDatabendColumnBuilders(): {
+    bigint: typeof bigint;
+    binary: typeof binary;
+    bitmap: typeof bitmap;
+    boolean: typeof boolean;
+    customType: typeof customType;
+    date: typeof date;
+    decimal: typeof decimal;
+    doublePrecision: typeof doublePrecision;
+    float: typeof float;
+    integer: typeof integer;
+    real: typeof real;
+    smallint: typeof smallint;
+    text: typeof text;
+    timestamp: typeof timestamp;
+    tinyint: typeof tinyint;
+    varchar: typeof varchar;
+    variant: typeof variant;
+};

package/dist/databend-core/columns/array.d.ts

@@ -0,0 +1,16 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendArrayBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string, elementType: string);
+    /** @internal */
+    build(table: any): DatabendArray;
+}
+export declare class DatabendArray extends DatabendColumn {
+    static readonly [entityKind]: string;
+    elementType: string;
+    constructor(table: any, config: any);
+    getSQLType(): string;
+    mapFromDriverValue(value: any): unknown[];
+}
+export declare function array(name: string, elementType: string): DatabendArrayBuilder;

package/dist/databend-core/columns/bigint.d.ts

@@ -0,0 +1,24 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendBigInt53Builder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendBigInt53;
+}
+export declare class DatabendBigInt53 extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare class DatabendBigInt64Builder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendBigInt64;
+}
+export declare class DatabendBigInt64 extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: any): bigint;
+}
+export declare function bigint(name?: string): DatabendBigInt53Builder;

package/dist/databend-core/columns/binary.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendBinaryBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendBinary;
+}
+export declare class DatabendBinary extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function binary(name?: string): DatabendBinaryBuilder;

package/dist/databend-core/columns/bitmap.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendBitmapBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendBitmap;
+}
+export declare class DatabendBitmap extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function bitmap(name?: string): DatabendBitmapBuilder;

package/dist/databend-core/columns/boolean.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendBooleanBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendBoolean;
+}
+export declare class DatabendBoolean extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function boolean(name?: string): DatabendBooleanBuilder;

package/dist/databend-core/columns/common.d.ts

@@ -0,0 +1,45 @@
+import { Column } from 'drizzle-orm/column';
+import { ColumnBuilder } from 'drizzle-orm/column-builder';
+import { entityKind } from 'drizzle-orm/entity';
+export declare class DatabendColumnBuilder extends ColumnBuilder {
+    static readonly [entityKind]: string;
+    generatedAlwaysAs(as: any, _config?: any): any;
+    unique(name?: string, config?: {
+        nulls?: string;
+    }): this;
+    /** @internal */
+    buildForeignKeys(_column: any, _table: any): any[];
+    /** @internal */
+    buildExtraConfigColumn(table: any): DatabendExtraConfigColumn;
+}
+export declare class DatabendColumn extends Column {
+    static readonly [entityKind]: string;
+    constructor(table: any, config: any);
+    getSQLType(): string;
+}
+export declare class DatabendExtraConfigColumn extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    indexConfig: {
+        order: any;
+        nulls: any;
+        opClass: any;
+    };
+    defaultConfig: {
+        order: "asc";
+        nulls: "last";
+        opClass: undefined;
+    };
+    asc(): this;
+    desc(): this;
+    nullsFirst(): this;
+    nullsLast(): this;
+}
+export declare class IndexedColumn {
+    static readonly [entityKind]: string;
+    name: string;
+    keyAsName: boolean;
+    type: string;
+    indexConfig: any;
+    constructor(name: string, keyAsName: boolean, type: string, indexConfig: any);
+}

package/dist/databend-core/columns/custom.d.ts

@@ -0,0 +1,33 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export interface CustomTypeValues {
+    data: unknown;
+    driverData?: unknown;
+    notNull: boolean;
+    default: boolean;
+}
+export interface CustomTypeParams<T extends CustomTypeValues> {
+    dataType: (config: any) => string;
+    toDriver?: (value: T['data']) => T['driverData'] | undefined;
+    fromDriver?: (value: T['driverData']) => T['data'];
+}
+export declare class DatabendCustomColumnBuilder<T extends CustomTypeValues> extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    private sqlDataType;
+    private mapTo?;
+    private mapFrom?;
+    constructor(name: string, fieldConfig: any, customTypeParams: CustomTypeParams<T>);
+    /** @internal */
+    build(table: any): DatabendCustomColumn<T>;
+}
+export declare class DatabendCustomColumn<T extends CustomTypeValues> extends DatabendColumn {
+    static readonly [entityKind]: string;
+    private sqlDataType;
+    private mapTo?;
+    private mapFrom?;
+    constructor(table: any, config: any, sqlDataType: string, mapTo?: (value: T['data']) => T['driverData'], mapFrom?: (value: T['driverData']) => T['data']);
+    getSQLType(): string;
+    mapFromDriverValue(value: any): T['data'];
+    mapToDriverValue(value: T['data']): T['driverData'];
+}
+export declare function customType<T extends CustomTypeValues>(customTypeParams: CustomTypeParams<T>): (dbName: string, fieldConfig?: any) => DatabendCustomColumnBuilder<T>;

package/dist/databend-core/columns/date.d.ts

@@ -0,0 +1,16 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendDateBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    defaultNow(): import("drizzle-orm").HasDefault<this>;
+    /** @internal */
+    build(table: any): DatabendDate;
+}
+export declare class DatabendDate extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: any): string;
+    mapToDriverValue(value: string | Date): string;
+}
+export declare function date(name?: string): DatabendDateBuilder;

package/dist/databend-core/columns/decimal.d.ts

@@ -0,0 +1,19 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendDecimalBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string, precision?: number, scale?: number);
+    /** @internal */
+    build(table: any): DatabendDecimal;
+}
+export declare class DatabendDecimal extends DatabendColumn {
+    static readonly [entityKind]: string;
+    precision: number | undefined;
+    scale: number | undefined;
+    constructor(table: any, config: any);
+    getSQLType(): string;
+}
+export declare function decimal(name?: string, config?: {
+    precision?: number;
+    scale?: number;
+}): DatabendDecimalBuilder;

package/dist/databend-core/columns/double.d.ts

@@ -0,0 +1,14 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendDoublePrecisionBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendDoublePrecision;
+}
+export declare class DatabendDoublePrecision extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: any): number;
+}
+export declare function doublePrecision(name?: string): DatabendDoublePrecisionBuilder;

package/dist/databend-core/columns/float.d.ts

@@ -0,0 +1,14 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendRealBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendReal;
+}
+export declare class DatabendReal extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function real(name?: string): DatabendRealBuilder;
+export declare function float(name?: string): DatabendRealBuilder;

package/dist/databend-core/columns/index.d.ts

@@ -0,0 +1,21 @@
+export * from './all.ts';
+export * from './array.ts';
+export * from './bigint.ts';
+export * from './binary.ts';
+export * from './bitmap.ts';
+export * from './boolean.ts';
+export * from './common.ts';
+export * from './custom.ts';
+export * from './date.ts';
+export * from './decimal.ts';
+export * from './double.ts';
+export * from './float.ts';
+export * from './integer.ts';
+export * from './map.ts';
+export * from './smallint.ts';
+export * from './text.ts';
+export * from './timestamp.ts';
+export * from './tinyint.ts';
+export * from './tuple.ts';
+export * from './varchar.ts';
+export * from './variant.ts';

package/dist/databend-core/columns/integer.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendIntegerBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendInteger;
+}
+export declare class DatabendInteger extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function integer(name?: string): DatabendIntegerBuilder;

package/dist/databend-core/columns/map.d.ts

@@ -0,0 +1,17 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendMapBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string, keyType: string, valueType: string);
+    /** @internal */
+    build(table: any): DatabendMap;
+}
+export declare class DatabendMap extends DatabendColumn {
+    static readonly [entityKind]: string;
+    keyType: string;
+    valueType: string;
+    constructor(table: any, config: any);
+    getSQLType(): string;
+    mapFromDriverValue(value: any): Record<string, unknown>;
+}
+export declare function map(name: string, keyType: string, valueType: string): DatabendMapBuilder;

package/dist/databend-core/columns/smallint.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendSmallIntBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendSmallInt;
+}
+export declare class DatabendSmallInt extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function smallint(name?: string): DatabendSmallIntBuilder;

package/dist/databend-core/columns/text.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendTextBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendText;
+}
+export declare class DatabendText extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function text(name?: string): DatabendTextBuilder;

package/dist/databend-core/columns/timestamp.d.ts

@@ -0,0 +1,16 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendTimestampBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    defaultNow(): import("drizzle-orm").HasDefault<this>;
+    /** @internal */
+    build(table: any): DatabendTimestamp;
+}
+export declare class DatabendTimestamp extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: any): Date;
+    mapToDriverValue(value: Date | string): string;
+}
+export declare function timestamp(name?: string): DatabendTimestampBuilder;

package/dist/databend-core/columns/tinyint.d.ts

@@ -0,0 +1,13 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendTinyIntBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendTinyInt;
+}
+export declare class DatabendTinyInt extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+}
+export declare function tinyint(name?: string): DatabendTinyIntBuilder;

package/dist/databend-core/columns/tuple.d.ts

@@ -0,0 +1,16 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendTupleBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string, types: string[]);
+    /** @internal */
+    build(table: any): DatabendTuple;
+}
+export declare class DatabendTuple extends DatabendColumn {
+    static readonly [entityKind]: string;
+    tupleTypes: string[];
+    constructor(table: any, config: any);
+    getSQLType(): string;
+    mapFromDriverValue(value: any): unknown;
+}
+export declare function tuple(name: string, types: string[]): DatabendTupleBuilder;

package/dist/databend-core/columns/varchar.d.ts

@@ -0,0 +1,17 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendVarcharBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string, length?: number);
+    /** @internal */
+    build(table: any): DatabendVarchar;
+}
+export declare class DatabendVarchar extends DatabendColumn {
+    static readonly [entityKind]: string;
+    length: number | undefined;
+    constructor(table: any, config: any);
+    getSQLType(): string;
+}
+export declare function varchar(name?: string, config?: {
+    length?: number;
+}): DatabendVarcharBuilder;

package/dist/databend-core/columns/variant.d.ts

@@ -0,0 +1,15 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { DatabendColumn, DatabendColumnBuilder } from './common.ts';
+export declare class DatabendVariantBuilder extends DatabendColumnBuilder {
+    static readonly [entityKind]: string;
+    constructor(name: string);
+    /** @internal */
+    build(table: any): DatabendVariant;
+}
+export declare class DatabendVariant extends DatabendColumn {
+    static readonly [entityKind]: string;
+    getSQLType(): string;
+    mapFromDriverValue(value: any): unknown;
+    mapToDriverValue(value: unknown): string;
+}
+export declare function variant(name?: string): DatabendVariantBuilder;

package/dist/databend-core/db.d.ts

@@ -0,0 +1,31 @@
+import { entityKind } from 'drizzle-orm/entity';
+import { WithSubquery } from 'drizzle-orm/subquery';
+import { DatabendCountBuilder } from './query-builders/count.ts';
+import { DatabendDeleteBase, DatabendInsertBuilder, DatabendSelectBuilder, DatabendUpdateBuilder } from './query-builders/index.ts';
+import { DatabendRaw } from './query-builders/raw.ts';
+export declare class DatabendDatabase {
+    dialect: any;
+    session: any;
+    static readonly [entityKind]: string;
+    _: any;
+    query: any;
+    constructor(dialect: any, session: any, schema?: any);
+    $with(alias: string): {
+        as(qb: any): WithSubquery<string, Record<string, unknown>>;
+    };
+    $count(source: any, filters?: any): DatabendCountBuilder;
+    with(...queries: any[]): {
+        select: (fields?: any) => DatabendSelectBuilder;
+        selectDistinct: (fields?: any) => DatabendSelectBuilder;
+        update: (table: any) => DatabendUpdateBuilder;
+        insert: (table: any) => DatabendInsertBuilder;
+        delete: (table: any) => DatabendDeleteBase;
+    };
+    select(fields?: any): DatabendSelectBuilder;
+    selectDistinct(fields?: any): DatabendSelectBuilder;
+    update(table: any): DatabendUpdateBuilder;
+    insert(table: any): DatabendInsertBuilder;
+    delete(table: any): DatabendDeleteBase;
+    execute(query: any): DatabendRaw;
+    transaction(transaction: any): any;
+}

package/dist/databend-core/dialect.d.ts

@@ -0,0 +1,29 @@
+import { entityKind } from 'drizzle-orm/entity';
+import type { MigrationConfig, MigrationMeta } from 'drizzle-orm/migrator';
+import { SQL } from 'drizzle-orm/sql/sql';
+export declare class DatabendDialect {
+    static readonly [entityKind]: string;
+    /** @internal */
+    casing: any;
+    constructor(config?: any);
+    migrate(migrations: MigrationMeta[], session: any, config: MigrationConfig | string): Promise<void>;
+    escapeName(name: string): string;
+    escapeParam(num: number): string;
+    escapeString(str: string): string;
+    buildWithCTE(queries: any[] | undefined): SQL<unknown> | undefined;
+    buildDeleteQuery({ table, where, withList }: any): SQL<unknown>;
+    buildUpdateSet(table: any, set: any): SQL<unknown>;
+    buildUpdateQuery({ table, set, where, withList }: any): SQL<unknown>;
+    buildSelection(fields: any[], { isSingleTable }?: {
+        isSingleTable?: boolean | undefined;
+    }): SQL<unknown>;
+    buildJoins(joins: any[] | undefined): SQL<unknown> | undefined;
+    buildFromTable(table: any): any;
+    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, distinct, setOperators, }: any): any;
+    buildSetOperations(leftSelect: any, setOperators: any[]): any;
+    buildSetOperationQuery({ leftSelect, setOperator: { type, isAll, rightSelect, limit, orderBy, offset }, }: any): SQL<unknown>;
+    buildInsertQuery({ table, values: valuesOrSelect, withList, select }: any): SQL<unknown>;
+    prepareTyping(encoder: any): string;
+    sqlToQuery(sql2: any, invokeSource?: any): any;
+    buildRelationalQueryWithoutPK({ fullSchema, schema, tableNamesMap, table, tableConfig, queryConfig: config, tableAlias, nestedQueryRelation, joinOn, }: any): any;
+}

package/dist/databend-core/index.d.ts

@@ -0,0 +1,18 @@
+export * from './alias.ts';
+export * from './columns/index.ts';
+export * from './db.ts';
+export * from './dialect.ts';
+export * from './indexes.ts';
+export * from './primary-keys.ts';
+export * from './query-builders/count.ts';
+export * from './query-builders/index.ts';
+export * from './query-builders/query.ts';
+export * from './query-builders/raw.ts';
+export * from './schema.ts';
+export * from './session.ts';
+export * from './subquery.ts';
+export * from './table.ts';
+export * from './utils.ts';
+export * from './view.ts';
+export * from './view-base.ts';
+export * from './view-common.ts';

package/dist/databend-core/indexes.d.ts

@@ -0,0 +1,24 @@
+import { entityKind } from 'drizzle-orm/entity';
+export declare class IndexBuilderOn {
+    private unique;
+    private name?;
+    static readonly [entityKind]: string;
+    constructor(unique: boolean, name?: string | undefined);
+    on(...columns: any[]): IndexBuilder;
+}
+export declare class IndexBuilder {
+    static readonly [entityKind]: string;
+    /** @internal */
+    config: any;
+    constructor(columns: any[], unique: boolean, name?: string);
+    where(condition: any): this;
+    /** @internal */
+    build(table: any): Index;
+}
+export declare class Index {
+    static readonly [entityKind]: string;
+    config: any;
+    constructor(config: any, table: any);
+}
+export declare function index(name?: string): IndexBuilderOn;
+export declare function uniqueIndex(name?: string): IndexBuilderOn;