@erfanium/drizzle-orm 1.0.0 → 1.0.1

package/singlestore-core/session.d.cts

@@ -1,86 +1,81 @@
-import { SingleStoreDialect } from "./dialect.cjs";
-import { SingleStoreDatabase } from "./db.cjs";
-import { SelectedFieldsOrdered } from "./query-builders/select.types.cjs";
-import { entityKind } from "../entity.cjs";
-import { Query, SQL } from "../sql/sql.cjs";
-import { Assume, Equal } from "../utils.cjs";
-import * as V1 from "../_relations.cjs";
-import { AnyRelations, EmptyRelations, RelationalQueryMapperConfig } from "../relations.cjs";
-import { WithCacheConfig } from "../cache/core/types.cjs";
-import { Cache } from "../cache/core/cache.cjs";
-
-//#region src/singlestore-core/session.d.ts
-interface SingleStoreQueryResultHKT {
-  readonly $brand: 'SingleStoreQueryResultHKT';
-  readonly row: unknown;
-  readonly type: unknown;
+import type * as V1 from '../_relations.cjs';
+import { type Cache } from '../cache/core/cache.cjs';
+import type { WithCacheConfig } from '../cache/core/types.cjs';
+import { entityKind } from '../entity.cjs';
+import type { AnyRelations, EmptyRelations, RelationalQueryMapperConfig } from '../relations.cjs';
+import { type Query, type SQL } from '../sql/sql.cjs';
+import type { Assume, Equal } from '../utils.cjs';
+import { SingleStoreDatabase } from './db.cjs';
+import type { SingleStoreDialect } from './dialect.cjs';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.cjs';
+export interface SingleStoreQueryResultHKT {
+    readonly $brand: 'SingleStoreQueryResultHKT';
+    readonly row: unknown;
+    readonly type: unknown;
 }
-interface AnySingleStoreQueryResultHKT extends SingleStoreQueryResultHKT {
-  readonly type: any;
+export interface AnySingleStoreQueryResultHKT extends SingleStoreQueryResultHKT {
+    readonly type: any;
 }
-type SingleStoreQueryResultKind<TKind extends SingleStoreQueryResultHKT, TRow> = (TKind & {
-  readonly row: TRow;
+export type SingleStoreQueryResultKind<TKind extends SingleStoreQueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
 })['type'];
-interface SingleStorePreparedQueryConfig {
-  execute: unknown;
-  iterator: unknown;
+export interface SingleStorePreparedQueryConfig {
+    execute: unknown;
+    iterator: unknown;
 }
-interface SingleStorePreparedQueryHKT {
-  readonly $brand: 'SingleStorePreparedQueryHKT';
-  readonly config: unknown;
-  readonly type: unknown;
+export interface SingleStorePreparedQueryHKT {
+    readonly $brand: 'SingleStorePreparedQueryHKT';
+    readonly config: unknown;
+    readonly type: unknown;
 }
-type PreparedQueryKind<TKind extends SingleStorePreparedQueryHKT, TConfig extends SingleStorePreparedQueryConfig, TAssume extends boolean = false> = Equal<TAssume, true> extends true ? Assume<(TKind & {
-  readonly config: TConfig;
+export type PreparedQueryKind<TKind extends SingleStorePreparedQueryHKT, TConfig extends SingleStorePreparedQueryConfig, TAssume extends boolean = false> = Equal<TAssume, true> extends true ? Assume<(TKind & {
+    readonly config: TConfig;
 })['type'], SingleStorePreparedQuery<TConfig>> : (TKind & {
-  readonly config: TConfig;
+    readonly config: TConfig;
 })['type'];
-declare abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQueryConfig> {
-  private cache?;
-  private queryMetadata?;
-  private cacheConfig?;
-  static readonly [entityKind]: string;
-  constructor(cache?: Cache | undefined, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  } | undefined, cacheConfig?: WithCacheConfig | undefined);
-  abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
-  abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
+export declare abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQueryConfig> {
+    private cache?;
+    private queryMetadata?;
+    private cacheConfig?;
+    static readonly [entityKind]: string;
+    constructor(cache?: Cache | undefined, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    } | undefined, cacheConfig?: WithCacheConfig | undefined);
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+    abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
 }
-interface SingleStoreTransactionConfig {
-  withConsistentSnapshot?: boolean;
-  accessMode?: 'read only' | 'read write';
-  isolationLevel: 'read committed';
+export interface SingleStoreTransactionConfig {
+    withConsistentSnapshot?: boolean;
+    accessMode?: 'read only' | 'read write';
+    isolationLevel: 'read committed';
 }
-declare abstract class SingleStoreSession<TQueryResult extends SingleStoreQueryResultHKT = SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
-  protected dialect: SingleStoreDialect;
-  static readonly [entityKind]: string;
-  constructor(dialect: SingleStoreDialect);
-  abstract prepareQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][]) => T['execute'], generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  }, cacheConfig?: WithCacheConfig): PreparedQueryKind<TPreparedQueryHKT, T>;
-  abstract prepareRelationalQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper: (rows: Record<string, unknown>[]) => T['execute'], config: RelationalQueryMapperConfig, generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered): PreparedQueryKind<TPreparedQueryHKT, T>;
-  execute<T>(query: SQL): Promise<T>;
-  abstract all<T = unknown>(query: SQL): Promise<T[]>;
-  count(sql: SQL): Promise<number>;
-  abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>, config?: SingleStoreTransactionConfig): Promise<T>;
-  protected getSetTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
-  protected getStartTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
+export declare abstract class SingleStoreSession<TQueryResult extends SingleStoreQueryResultHKT = SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
+    protected dialect: SingleStoreDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: SingleStoreDialect);
+    abstract prepareQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][]) => T['execute'], generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    }, cacheConfig?: WithCacheConfig): PreparedQueryKind<TPreparedQueryHKT, T>;
+    abstract prepareRelationalQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper: (rows: Record<string, unknown>[]) => T['execute'], config: RelationalQueryMapperConfig, generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered): PreparedQueryKind<TPreparedQueryHKT, T>;
+    execute<T>(query: SQL): Promise<T>;
+    abstract all<T = unknown>(query: SQL): Promise<T[]>;
+    count(sql: SQL): Promise<number>;
+    abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>, config?: SingleStoreTransactionConfig): Promise<T>;
+    protected getSetTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
+    protected getStartTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
 }
-declare abstract class SingleStoreTransaction<TQueryResult extends SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema> {
-  protected relations: TRelations;
-  protected schema: V1.RelationalSchemaConfig<TSchema> | undefined;
-  protected readonly nestedIndex: number;
-  static readonly [entityKind]: string;
-  constructor(dialect: SingleStoreDialect, session: SingleStoreSession, relations: TRelations, schema: V1.RelationalSchemaConfig<TSchema> | undefined, nestedIndex: number);
-  rollback(): never;
-  /** Nested transactions (aka savepoints) only work with InnoDB engine. */
-  abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>): Promise<T>;
+export declare abstract class SingleStoreTransaction<TQueryResult extends SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema> {
+    protected relations: TRelations;
+    protected schema: V1.RelationalSchemaConfig<TSchema> | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(dialect: SingleStoreDialect, session: SingleStoreSession, relations: TRelations, schema: V1.RelationalSchemaConfig<TSchema> | undefined, nestedIndex: number);
+    rollback(): never;
+    /** Nested transactions (aka savepoints) only work with InnoDB engine. */
+    abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>): Promise<T>;
 }
-interface PreparedQueryHKTBase extends SingleStorePreparedQueryHKT {
-  type: SingleStorePreparedQuery<Assume<this['config'], SingleStorePreparedQueryConfig>>;
+export interface PreparedQueryHKTBase extends SingleStorePreparedQueryHKT {
+    type: SingleStorePreparedQuery<Assume<this['config'], SingleStorePreparedQueryConfig>>;
 }
-//#endregion
-export { AnySingleStoreQueryResultHKT, PreparedQueryHKTBase, PreparedQueryKind, SingleStorePreparedQuery, SingleStorePreparedQueryConfig, SingleStorePreparedQueryHKT, SingleStoreQueryResultHKT, SingleStoreQueryResultKind, SingleStoreSession, SingleStoreTransaction, SingleStoreTransactionConfig };
-//# sourceMappingURL=session.d.cts.map

package/singlestore-core/session.d.ts

@@ -1,86 +1,81 @@
-import { SingleStoreDialect } from "./dialect.js";
-import { SingleStoreDatabase } from "./db.js";
-import { SelectedFieldsOrdered } from "./query-builders/select.types.js";
-import { entityKind } from "../entity.js";
-import { Assume, Equal } from "../utils.js";
-import { Query, SQL } from "../sql/sql.js";
-import { Cache } from "../cache/core/cache.js";
-import * as V1 from "../_relations.js";
-import { AnyRelations, EmptyRelations, RelationalQueryMapperConfig } from "../relations.js";
-import { WithCacheConfig } from "../cache/core/types.js";
-
-//#region src/singlestore-core/session.d.ts
-interface SingleStoreQueryResultHKT {
-  readonly $brand: 'SingleStoreQueryResultHKT';
-  readonly row: unknown;
-  readonly type: unknown;
+import type * as V1 from '../_relations.js';
+import { type Cache } from '../cache/core/cache.js';
+import type { WithCacheConfig } from '../cache/core/types.js';
+import { entityKind } from '../entity.js';
+import type { AnyRelations, EmptyRelations, RelationalQueryMapperConfig } from '../relations.js';
+import { type Query, type SQL } from '../sql/sql.js';
+import type { Assume, Equal } from '../utils.js';
+import { SingleStoreDatabase } from './db.js';
+import type { SingleStoreDialect } from './dialect.js';
+import type { SelectedFieldsOrdered } from './query-builders/select.types.js';
+export interface SingleStoreQueryResultHKT {
+    readonly $brand: 'SingleStoreQueryResultHKT';
+    readonly row: unknown;
+    readonly type: unknown;
 }
-interface AnySingleStoreQueryResultHKT extends SingleStoreQueryResultHKT {
-  readonly type: any;
+export interface AnySingleStoreQueryResultHKT extends SingleStoreQueryResultHKT {
+    readonly type: any;
 }
-type SingleStoreQueryResultKind<TKind extends SingleStoreQueryResultHKT, TRow> = (TKind & {
-  readonly row: TRow;
+export type SingleStoreQueryResultKind<TKind extends SingleStoreQueryResultHKT, TRow> = (TKind & {
+    readonly row: TRow;
 })['type'];
-interface SingleStorePreparedQueryConfig {
-  execute: unknown;
-  iterator: unknown;
+export interface SingleStorePreparedQueryConfig {
+    execute: unknown;
+    iterator: unknown;
 }
-interface SingleStorePreparedQueryHKT {
-  readonly $brand: 'SingleStorePreparedQueryHKT';
-  readonly config: unknown;
-  readonly type: unknown;
+export interface SingleStorePreparedQueryHKT {
+    readonly $brand: 'SingleStorePreparedQueryHKT';
+    readonly config: unknown;
+    readonly type: unknown;
 }
-type PreparedQueryKind<TKind extends SingleStorePreparedQueryHKT, TConfig extends SingleStorePreparedQueryConfig, TAssume extends boolean = false> = Equal<TAssume, true> extends true ? Assume<(TKind & {
-  readonly config: TConfig;
+export type PreparedQueryKind<TKind extends SingleStorePreparedQueryHKT, TConfig extends SingleStorePreparedQueryConfig, TAssume extends boolean = false> = Equal<TAssume, true> extends true ? Assume<(TKind & {
+    readonly config: TConfig;
 })['type'], SingleStorePreparedQuery<TConfig>> : (TKind & {
-  readonly config: TConfig;
+    readonly config: TConfig;
 })['type'];
-declare abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQueryConfig> {
-  private cache?;
-  private queryMetadata?;
-  private cacheConfig?;
-  static readonly [entityKind]: string;
-  constructor(cache?: Cache | undefined, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  } | undefined, cacheConfig?: WithCacheConfig | undefined);
-  abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
-  abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
+export declare abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQueryConfig> {
+    private cache?;
+    private queryMetadata?;
+    private cacheConfig?;
+    static readonly [entityKind]: string;
+    constructor(cache?: Cache | undefined, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    } | undefined, cacheConfig?: WithCacheConfig | undefined);
+    abstract execute(placeholderValues?: Record<string, unknown>): Promise<T['execute']>;
+    abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
 }
-interface SingleStoreTransactionConfig {
-  withConsistentSnapshot?: boolean;
-  accessMode?: 'read only' | 'read write';
-  isolationLevel: 'read committed';
+export interface SingleStoreTransactionConfig {
+    withConsistentSnapshot?: boolean;
+    accessMode?: 'read only' | 'read write';
+    isolationLevel: 'read committed';
 }
-declare abstract class SingleStoreSession<TQueryResult extends SingleStoreQueryResultHKT = SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
-  protected dialect: SingleStoreDialect;
-  static readonly [entityKind]: string;
-  constructor(dialect: SingleStoreDialect);
-  abstract prepareQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][]) => T['execute'], generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  }, cacheConfig?: WithCacheConfig): PreparedQueryKind<TPreparedQueryHKT, T>;
-  abstract prepareRelationalQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper: (rows: Record<string, unknown>[]) => T['execute'], config: RelationalQueryMapperConfig, generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered): PreparedQueryKind<TPreparedQueryHKT, T>;
-  execute<T>(query: SQL): Promise<T>;
-  abstract all<T = unknown>(query: SQL): Promise<T[]>;
-  count(sql: SQL): Promise<number>;
-  abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>, config?: SingleStoreTransactionConfig): Promise<T>;
-  protected getSetTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
-  protected getStartTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
+export declare abstract class SingleStoreSession<TQueryResult extends SingleStoreQueryResultHKT = SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> {
+    protected dialect: SingleStoreDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: SingleStoreDialect);
+    abstract prepareQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][]) => T['execute'], generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    }, cacheConfig?: WithCacheConfig): PreparedQueryKind<TPreparedQueryHKT, T>;
+    abstract prepareRelationalQuery<T extends SingleStorePreparedQueryConfig, TPreparedQueryHKT extends SingleStorePreparedQueryHKT>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper: (rows: Record<string, unknown>[]) => T['execute'], config: RelationalQueryMapperConfig, generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered): PreparedQueryKind<TPreparedQueryHKT, T>;
+    execute<T>(query: SQL): Promise<T>;
+    abstract all<T = unknown>(query: SQL): Promise<T[]>;
+    count(sql: SQL): Promise<number>;
+    abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>, config?: SingleStoreTransactionConfig): Promise<T>;
+    protected getSetTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
+    protected getStartTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined;
 }
-declare abstract class SingleStoreTransaction<TQueryResult extends SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema> {
-  protected relations: TRelations;
-  protected schema: V1.RelationalSchemaConfig<TSchema> | undefined;
-  protected readonly nestedIndex: number;
-  static readonly [entityKind]: string;
-  constructor(dialect: SingleStoreDialect, session: SingleStoreSession, relations: TRelations, schema: V1.RelationalSchemaConfig<TSchema> | undefined, nestedIndex: number);
-  rollback(): never;
-  /** Nested transactions (aka savepoints) only work with InnoDB engine. */
-  abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>): Promise<T>;
+export declare abstract class SingleStoreTransaction<TQueryResult extends SingleStoreQueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations, TSchema extends V1.TablesRelationalConfig = Record<string, never>> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema> {
+    protected relations: TRelations;
+    protected schema: V1.RelationalSchemaConfig<TSchema> | undefined;
+    protected readonly nestedIndex: number;
+    static readonly [entityKind]: string;
+    constructor(dialect: SingleStoreDialect, session: SingleStoreSession, relations: TRelations, schema: V1.RelationalSchemaConfig<TSchema> | undefined, nestedIndex: number);
+    rollback(): never;
+    /** Nested transactions (aka savepoints) only work with InnoDB engine. */
+    abstract transaction<T>(transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TRelations, TSchema>) => Promise<T>): Promise<T>;
 }
-interface PreparedQueryHKTBase extends SingleStorePreparedQueryHKT {
-  type: SingleStorePreparedQuery<Assume<this['config'], SingleStorePreparedQueryConfig>>;
+export interface PreparedQueryHKTBase extends SingleStorePreparedQueryHKT {
+    type: SingleStorePreparedQuery<Assume<this['config'], SingleStorePreparedQueryConfig>>;
 }
-//#endregion
-export { AnySingleStoreQueryResultHKT, PreparedQueryHKTBase, PreparedQueryKind, SingleStorePreparedQuery, SingleStorePreparedQueryConfig, SingleStorePreparedQueryHKT, SingleStoreQueryResultHKT, SingleStoreQueryResultKind, SingleStoreSession, SingleStoreTransaction, SingleStoreTransactionConfig };
-//# sourceMappingURL=session.d.ts.map

package/singlestore-core/subquery.d.cts

@@ -1,23 +1,18 @@
-import { QueryBuilder } from "./query-builders/query-builder.cjs";
-import { TypedQueryBuilder } from "../query-builders/query-builder.cjs";
-import { AddAliasToSelection } from "../query-builders/select.types.cjs";
-import { ColumnsSelection, SQL } from "../sql/sql.cjs";
-import { Subquery, WithSubquery, WithSubqueryWithoutSelection } from "../subquery.cjs";
-
-//#region src/singlestore-core/subquery.d.ts
-type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
-type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
-interface WithBuilder {
-  <TAlias extends string>(alias: TAlias): {
-    as: {
-      <TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): WithSubqueryWithSelection<TSelection, TAlias>;
-      (qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>)): WithSubqueryWithoutSelection<TAlias>;
+import type { TypedQueryBuilder } from '../query-builders/query-builder.cjs';
+import type { AddAliasToSelection } from '../query-builders/select.types.cjs';
+import type { ColumnsSelection, SQL } from '../sql/sql.cjs';
+import type { Subquery, WithSubquery, WithSubqueryWithoutSelection } from '../subquery.cjs';
+import type { QueryBuilder } from './query-builders/query-builder.cjs';
+export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
+export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
+export interface WithBuilder {
+    <TAlias extends string>(alias: TAlias): {
+        as: {
+            <TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): WithSubqueryWithSelection<TSelection, TAlias>;
+            (qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>)): WithSubqueryWithoutSelection<TAlias>;
+        };
+    };
+    <TAlias extends string, TSelection extends ColumnsSelection>(alias: TAlias, selection: TSelection): {
+        as: (qb: SQL | ((qb: QueryBuilder) => SQL)) => WithSubqueryWithSelection<TSelection, TAlias>;
     };
-  };
-  <TAlias extends string, TSelection extends ColumnsSelection>(alias: TAlias, selection: TSelection): {
-    as: (qb: SQL | ((qb: QueryBuilder) => SQL)) => WithSubqueryWithSelection<TSelection, TAlias>;
-  };
 }
-//#endregion
-export { SubqueryWithSelection, WithBuilder, WithSubqueryWithSelection };
-//# sourceMappingURL=subquery.d.cts.map

package/singlestore-core/subquery.d.ts

@@ -1,23 +1,18 @@
-import { QueryBuilder } from "./query-builders/query-builder.js";
-import { ColumnsSelection, SQL } from "../sql/sql.js";
-import { Subquery, WithSubquery, WithSubqueryWithoutSelection } from "../subquery.js";
-import { TypedQueryBuilder } from "../query-builders/query-builder.js";
-import { AddAliasToSelection } from "../query-builders/select.types.js";
-
-//#region src/singlestore-core/subquery.d.ts
-type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
-type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
-interface WithBuilder {
-  <TAlias extends string>(alias: TAlias): {
-    as: {
-      <TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): WithSubqueryWithSelection<TSelection, TAlias>;
-      (qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>)): WithSubqueryWithoutSelection<TAlias>;
+import type { TypedQueryBuilder } from '../query-builders/query-builder.js';
+import type { AddAliasToSelection } from '../query-builders/select.types.js';
+import type { ColumnsSelection, SQL } from '../sql/sql.js';
+import type { Subquery, WithSubquery, WithSubqueryWithoutSelection } from '../subquery.js';
+import type { QueryBuilder } from './query-builders/query-builder.js';
+export type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
+export type WithSubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>> & AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
+export interface WithBuilder {
+    <TAlias extends string>(alias: TAlias): {
+        as: {
+            <TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): WithSubqueryWithSelection<TSelection, TAlias>;
+            (qb: TypedQueryBuilder<undefined> | ((qb: QueryBuilder) => TypedQueryBuilder<undefined>)): WithSubqueryWithoutSelection<TAlias>;
+        };
+    };
+    <TAlias extends string, TSelection extends ColumnsSelection>(alias: TAlias, selection: TSelection): {
+        as: (qb: SQL | ((qb: QueryBuilder) => SQL)) => WithSubqueryWithSelection<TSelection, TAlias>;
     };
-  };
-  <TAlias extends string, TSelection extends ColumnsSelection>(alias: TAlias, selection: TSelection): {
-    as: (qb: SQL | ((qb: QueryBuilder) => SQL)) => WithSubqueryWithSelection<TSelection, TAlias>;
-  };
 }
-//#endregion
-export { SubqueryWithSelection, WithBuilder, WithSubqueryWithSelection };
-//# sourceMappingURL=subquery.d.ts.map

package/singlestore-core/table.d.cts

@@ -1,100 +1,95 @@
-import { SingleStoreColumns } from "./columns/common.cjs";
-import { SingleStoreColumnBuilders } from "./columns/all.cjs";
-import { AnyIndexBuilder } from "./indexes.cjs";
-import { PrimaryKeyBuilder } from "./primary-keys.cjs";
-import { UniqueConstraintBuilder } from "./unique-constraint.cjs";
-import { entityKind } from "../entity.cjs";
-import { InferTableColumnsModels, Table, TableConfig as TableConfig$1, UpdateTableConfig } from "../table.cjs";
-import { BuildColumns, ColumnBuilderBase } from "../column-builder.cjs";
-import { Casing } from "../casing.cjs";
-
-//#region src/singlestore-core/table.d.ts
-type SingleStoreTableExtraConfigValue = AnyIndexBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder;
-type SingleStoreTableExtraConfig = Record<string, SingleStoreTableExtraConfigValue>;
-type TableConfig = TableConfig$1<SingleStoreColumns>;
-declare class SingleStoreTable<T extends TableConfig = TableConfig> extends Table<T> {
-  static readonly [entityKind]: string;
+import { type Casing } from '../casing.cjs';
+import type { BuildColumns, ColumnBuilderBase } from '../column-builder.cjs';
+import { entityKind } from '../entity.cjs';
+import { type InferTableColumnsModels, Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '../table.cjs';
+import { type SingleStoreColumnBuilders } from './columns/all.cjs';
+import type { SingleStoreColumns } from './columns/common.cjs';
+import type { AnyIndexBuilder } from './indexes.cjs';
+import type { PrimaryKeyBuilder } from './primary-keys.cjs';
+import type { UniqueConstraintBuilder } from './unique-constraint.cjs';
+export type SingleStoreTableExtraConfigValue = AnyIndexBuilder | PrimaryKeyBuilder | UniqueConstraintBuilder;
+export type SingleStoreTableExtraConfig = Record<string, SingleStoreTableExtraConfigValue>;
+export type TableConfig = TableConfigBase<SingleStoreColumns>;
+export declare class SingleStoreTable<T extends TableConfig = TableConfig> extends Table<T> {
+    static readonly [entityKind]: string;
 }
-type AnySingleStoreTable<TPartial extends Partial<TableConfig> = {}> = SingleStoreTable<UpdateTableConfig<TableConfig, TPartial>>;
-type SingleStoreTableWithColumns<T extends TableConfig> = SingleStoreTable<T> & T['columns'] & InferTableColumnsModels<T['columns']>;
-declare function singlestoreTableWithSchema<TTableName extends string, TSchemaName extends string | undefined, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: TColumnsMap | ((columnTypes: SingleStoreColumnBuilders) => TColumnsMap), extraConfig: ((self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig | SingleStoreTableExtraConfigValue[]) | undefined, schema: TSchemaName, casing: Casing | undefined, baseName?: TTableName): SingleStoreTableWithColumns<{
-  name: TTableName;
-  schema: TSchemaName;
-  columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
-  dialect: 'singlestore';
-}>;
-interface SingleStoreTableFn<TSchemaName extends string | undefined = undefined> {
-  <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfigValue[]): SingleStoreTableWithColumns<{
-    name: TTableName;
-    schema: TSchemaName;
-    columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
-    dialect: 'singlestore';
-  }>;
-  <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: (columnTypes: SingleStoreColumnBuilders) => TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfigValue[]): SingleStoreTableWithColumns<{
-    name: TTableName;
-    schema: TSchemaName;
-    columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
-    dialect: 'singlestore';
-  }>;
-  /**
-   * @deprecated The third parameter of singlestoreTable is changing and will only accept an array instead of an object
-   *
-   * @example
-   * Deprecated version:
-   * ```ts
-   * export const users = singlestoreTable("users", {
-   * 	id: int(),
-   * }, (t) => ({
-   * 	idx: index('custom_name').on(t.id)
-   * }));
-   * ```
-   *
-   * New API:
-   * ```ts
-   * export const users = singlestoreTable("users", {
-   * 	id: int(),
-   * }, (t) => [
-   * 	index('custom_name').on(t.id)
-   * ]);
-   * ```
-   */
-  <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig): SingleStoreTableWithColumns<{
+export type AnySingleStoreTable<TPartial extends Partial<TableConfig> = {}> = SingleStoreTable<UpdateTableConfig<TableConfig, TPartial>>;
+export type SingleStoreTableWithColumns<T extends TableConfig> = SingleStoreTable<T> & T['columns'] & InferTableColumnsModels<T['columns']>;
+export declare function singlestoreTableWithSchema<TTableName extends string, TSchemaName extends string | undefined, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: TColumnsMap | ((columnTypes: SingleStoreColumnBuilders) => TColumnsMap), extraConfig: ((self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig | SingleStoreTableExtraConfigValue[]) | undefined, schema: TSchemaName, casing: Casing | undefined, baseName?: TTableName): SingleStoreTableWithColumns<{
     name: TTableName;
     schema: TSchemaName;
     columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
     dialect: 'singlestore';
-  }>;
-  /**
-   * @deprecated The third parameter of singlestoreTable is changing and will only accept an array instead of an object
-   *
-   * @example
-   * Deprecated version:
-   * ```ts
-   * export const users = singlestoreTable("users", {
-   * 	id: int(),
-   * }, (t) => ({
-   * 	idx: index('custom_name').on(t.id)
-   * }));
-   * ```
-   *
-   * New API:
-   * ```ts
-   * export const users = singlestoreTable("users", {
-   * 	id: int(),
-   * }, (t) => [
-   * 	index('custom_name').on(t.id)
-   * ]);
-   * ```
-   */
-  <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: (columnTypes: SingleStoreColumnBuilders) => TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig): SingleStoreTableWithColumns<{
-    name: TTableName;
-    schema: TSchemaName;
-    columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
-    dialect: 'singlestore';
-  }>;
+}>;
+export interface SingleStoreTableFn<TSchemaName extends string | undefined = undefined> {
+    <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfigValue[]): SingleStoreTableWithColumns<{
+        name: TTableName;
+        schema: TSchemaName;
+        columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+        dialect: 'singlestore';
+    }>;
+    <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: (columnTypes: SingleStoreColumnBuilders) => TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfigValue[]): SingleStoreTableWithColumns<{
+        name: TTableName;
+        schema: TSchemaName;
+        columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+        dialect: 'singlestore';
+    }>;
+    /**
+     * @deprecated The third parameter of singlestoreTable is changing and will only accept an array instead of an object
+     *
+     * @example
+     * Deprecated version:
+     * ```ts
+     * export const users = singlestoreTable("users", {
+     * 	id: int(),
+     * }, (t) => ({
+     * 	idx: index('custom_name').on(t.id)
+     * }));
+     * ```
+     *
+     * New API:
+     * ```ts
+     * export const users = singlestoreTable("users", {
+     * 	id: int(),
+     * }, (t) => [
+     * 	index('custom_name').on(t.id)
+     * ]);
+     * ```
+     */
+    <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig): SingleStoreTableWithColumns<{
+        name: TTableName;
+        schema: TSchemaName;
+        columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+        dialect: 'singlestore';
+    }>;
+    /**
+     * @deprecated The third parameter of singlestoreTable is changing and will only accept an array instead of an object
+     *
+     * @example
+     * Deprecated version:
+     * ```ts
+     * export const users = singlestoreTable("users", {
+     * 	id: int(),
+     * }, (t) => ({
+     * 	idx: index('custom_name').on(t.id)
+     * }));
+     * ```
+     *
+     * New API:
+     * ```ts
+     * export const users = singlestoreTable("users", {
+     * 	id: int(),
+     * }, (t) => [
+     * 	index('custom_name').on(t.id)
+     * ]);
+     * ```
+     */
+    <TTableName extends string, TColumnsMap extends Record<string, ColumnBuilderBase>>(name: TTableName, columns: (columnTypes: SingleStoreColumnBuilders) => TColumnsMap, extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig): SingleStoreTableWithColumns<{
+        name: TTableName;
+        schema: TSchemaName;
+        columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+        dialect: 'singlestore';
+    }>;
 }
-declare const singlestoreTable: SingleStoreTableFn<undefined>;
-declare function singlestoreTableCreator(customizeTableName: (name: string) => string, casing?: Casing | undefined): SingleStoreTableFn;
-//#endregion
-export { AnySingleStoreTable, SingleStoreTable, SingleStoreTableExtraConfig, SingleStoreTableExtraConfigValue, SingleStoreTableFn, SingleStoreTableWithColumns, TableConfig, singlestoreTable, singlestoreTableCreator, singlestoreTableWithSchema };
-//# sourceMappingURL=table.d.cts.map
+export declare const singlestoreTable: SingleStoreTableFn<undefined>;
+export declare function singlestoreTableCreator(customizeTableName: (name: string) => string, casing?: Casing | undefined): SingleStoreTableFn;