@opencode-ai/core 0.0.0-dev-17471

package/dist/types/database/drizzle/sqlite-core/effect/db.d.ts

@@ -0,0 +1,77 @@
+import { Effect } from "effect";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { EffectCacheShape } from "drizzle-orm/cache/core/cache-effect";
+import type { QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import { type SQL, type SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+import type { SelectedFields } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { SQLiteTransactionConfig } from "drizzle-orm/sqlite-core/session";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import type { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { WithSubquery } from "drizzle-orm/subquery";
+import type { WithBuilder } from "drizzle-orm/sqlite-core/subquery";
+import { SQLiteEffectCountBuilder } from "./count.js";
+import { SQLiteEffectDeleteBase } from "./delete.js";
+import { SQLiteEffectInsertBuilder } from "./insert.js";
+import { SQLiteEffectRelationalQueryBuilder } from "./query.js";
+import { SQLiteEffectRaw } from "./raw.js";
+import { SQLiteEffectSelectBuilder } from "./select.js";
+import type { SQLiteEffectSelectBase } from "./select.js";
+import type { SQLiteEffectSession, SQLiteEffectTransaction } from "./session.js";
+import { SQLiteEffectUpdateBuilder } from "./update.js";
+export declare class SQLiteEffectDatabase<TEffectHKT extends QueryEffectHKTBase, TRunResult, TRelations extends AnyRelations = EmptyRelations> {
+    /** @internal */
+    readonly dialect: SQLiteAsyncDialect;
+    /** @internal */
+    readonly session: SQLiteEffectSession<TEffectHKT, TRunResult, TRelations>;
+    readonly rowModeRQB?: boolean | undefined;
+    readonly forbidJsonb?: boolean | undefined;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly relations: TRelations;
+        readonly session: SQLiteEffectSession<TEffectHKT, TRunResult, TRelations>;
+    };
+    query: {
+        [K in keyof TRelations]: SQLiteEffectRelationalQueryBuilder<TRelations, TRelations[K], TEffectHKT>;
+    };
+    constructor(
+    /** @internal */
+    dialect: SQLiteAsyncDialect, 
+    /** @internal */
+    session: SQLiteEffectSession<TEffectHKT, TRunResult, TRelations>, relations: TRelations, rowModeRQB?: boolean | undefined, forbidJsonb?: boolean | undefined);
+    $with: WithBuilder;
+    $cache: {
+        invalidate: EffectCacheShape["onMutate"];
+    };
+    $count(source: SQLiteTable | SQLiteViewBase | SQL | SQLWrapper, filters?: SQL<unknown>): SQLiteEffectCountBuilder<TEffectHKT>;
+    with(...queries: WithSubquery[]): {
+        select: {
+            (): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+            <TSelection extends SelectedFields>(fields: TSelection): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+        };
+        selectDistinct: {
+            (): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+            <TSelection extends SelectedFields>(fields: TSelection): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+        };
+        update: <TTable extends SQLiteTable>(table: TTable) => SQLiteEffectUpdateBuilder<TTable, TRunResult, TEffectHKT>;
+        insert: <TTable extends SQLiteTable>(into: TTable) => SQLiteEffectInsertBuilder<TTable, TRunResult, TEffectHKT>;
+        delete: <TTable extends SQLiteTable>(from: TTable) => SQLiteEffectDeleteBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    };
+    select(): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+    select<TSelection extends SelectedFields>(fields: TSelection): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+    selectDistinct(): SQLiteEffectSelectBuilder<undefined, TRunResult, TEffectHKT>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): SQLiteEffectSelectBuilder<TSelection, TRunResult, TEffectHKT>;
+    update<TTable extends SQLiteTable>(table: TTable): SQLiteEffectUpdateBuilder<TTable, TRunResult, TEffectHKT>;
+    insert<TTable extends SQLiteTable>(into: TTable): SQLiteEffectInsertBuilder<TTable, TRunResult, TEffectHKT>;
+    delete<TTable extends SQLiteTable>(from: TTable): SQLiteEffectDeleteBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    private raw;
+    run(query: SQLWrapper | string): SQLiteEffectRaw<TRunResult, TEffectHKT>;
+    all<T = unknown>(query: SQLWrapper | string): SQLiteEffectRaw<T[], TEffectHKT>;
+    get<T = unknown>(query: SQLWrapper | string): SQLiteEffectRaw<T | undefined, TEffectHKT>;
+    values<T extends unknown[] = unknown[]>(query: SQLWrapper | string): SQLiteEffectRaw<T[], TEffectHKT>;
+    transaction: <A, E, R>(transaction: (tx: SQLiteEffectTransaction<TEffectHKT, TRunResult, TRelations>) => Effect.Effect<A, E, R>, config?: SQLiteTransactionConfig) => Effect.Effect<A, E | SqlError, R>;
+}
+export type AnySQLiteEffectDatabase = SQLiteEffectDatabase<any, any, any>;
+export type AnySQLiteEffectSelectBase = SQLiteEffectSelectBase<any, any, any, any, any, any, any, any, any, any>;

package/dist/types/database/drizzle/sqlite-core/effect/delete.d.ts

@@ -0,0 +1,69 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { SelectResultFields } from "drizzle-orm/query-builders/select.types";
+import type { RunnableQuery } from "drizzle-orm/runnable-query";
+import type { Placeholder, Query, SQL, SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+import type { SQLiteDeleteConfig } from "drizzle-orm/sqlite-core/query-builders/delete";
+import type { SelectedFieldsFlat } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { PreparedQueryConfig } from "drizzle-orm/sqlite-core/session";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import type { Subquery } from "drizzle-orm/subquery";
+import { type DrizzleTypeError, type ValueOrArray } from "drizzle-orm/utils";
+import type { SQLiteColumn } from "drizzle-orm/sqlite-core/columns/common";
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from "./session.js";
+export type SQLiteEffectDeleteWithout<T extends AnySQLiteEffectDelete, TDynamic extends boolean, K extends keyof T & string> = TDynamic extends true ? T : Omit<SQLiteEffectDeleteBase<T["_"]["table"], T["_"]["runResult"], T["_"]["returning"], TDynamic, T["_"]["excludedMethods"] | K, T["_"]["effectHKT"]>, T["_"]["excludedMethods"] | K>;
+export type SQLiteEffectDeleteReturningAll<T extends AnySQLiteEffectDelete, TDynamic extends boolean> = SQLiteEffectDeleteWithout<SQLiteEffectDeleteBase<T["_"]["table"], T["_"]["runResult"], T["_"]["table"]["$inferSelect"], T["_"]["dynamic"], T["_"]["excludedMethods"], T["_"]["effectHKT"]>, TDynamic, "returning">;
+export type SQLiteEffectDeleteReturning<T extends AnySQLiteEffectDelete, TDynamic extends boolean, TSelectedFields extends SelectedFieldsFlat> = SQLiteEffectDeleteWithout<SQLiteEffectDeleteBase<T["_"]["table"], T["_"]["runResult"], SelectResultFields<TSelectedFields>, T["_"]["dynamic"], T["_"]["excludedMethods"], T["_"]["effectHKT"]>, TDynamic, "returning">;
+export type SQLiteEffectDeleteExecute<T extends AnySQLiteEffectDelete> = T["_"]["returning"] extends undefined ? T["_"]["runResult"] : T["_"]["returning"][];
+export type SQLiteEffectDeletePrepare<T extends AnySQLiteEffectDelete, TEffectHKT extends QueryEffectHKTBase = T["_"]["effectHKT"]> = SQLiteEffectPreparedQuery<PreparedQueryConfig & {
+    run: T["_"]["runResult"];
+    all: T["_"]["returning"] extends undefined ? DrizzleTypeError<".all() cannot be used without .returning()"> : T["_"]["returning"][];
+    get: T["_"]["returning"] extends undefined ? DrizzleTypeError<".get() cannot be used without .returning()"> : T["_"]["returning"] | undefined;
+    values: T["_"]["returning"] extends undefined ? DrizzleTypeError<".values() cannot be used without .returning()"> : any[][];
+    execute: SQLiteEffectDeleteExecute<T>;
+}, TEffectHKT>;
+export type SQLiteEffectDeleteDynamic<T extends AnySQLiteEffectDelete> = SQLiteEffectDelete<T["_"]["table"], T["_"]["runResult"], T["_"]["returning"], T["_"]["effectHKT"]>;
+export type SQLiteEffectDelete<TTable extends SQLiteTable = SQLiteTable, TRunResult = unknown, TReturning extends Record<string, unknown> | undefined = undefined, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> = SQLiteEffectDeleteBase<TTable, TRunResult, TReturning, true, never, TEffectHKT>;
+export type AnySQLiteEffectDelete = SQLiteEffectDeleteBase<any, any, any, any, any, any>;
+export interface SQLiteEffectDeleteBase<out TTable extends SQLiteTable, out TRunResult, out TReturning extends Record<string, unknown> | undefined = undefined, out TDynamic extends boolean = false, _TExcludedMethods extends string = never, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], "sqlite">, SQLWrapper, Effect.Effect<TReturning extends undefined ? TRunResult : TReturning[], TEffectHKT["error"], TEffectHKT["context"]> {
+    readonly _: {
+        dialect: "sqlite";
+        readonly table: TTable;
+        readonly resultType: "async";
+        readonly runResult: TRunResult;
+        readonly returning: TReturning;
+        readonly dynamic: TDynamic;
+        readonly excludedMethods: _TExcludedMethods;
+        readonly result: TReturning extends undefined ? TRunResult : TReturning[];
+        readonly effectHKT: TEffectHKT;
+    };
+}
+export declare class SQLiteEffectDeleteBase<out TTable extends SQLiteTable, out TRunResult, out TReturning extends Record<string, unknown> | undefined = undefined, out TDynamic extends boolean = false, _TExcludedMethods extends string = never, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], "sqlite">, SQLWrapper {
+    private table;
+    private effectSession;
+    private effectDialect;
+    static readonly [entityKind]: string;
+    /** @internal */
+    config: SQLiteDeleteConfig;
+    constructor(table: TTable, effectSession: SQLiteEffectSession<TEffectHKT, TRunResult, any>, effectDialect: SQLiteDialect, withList?: Subquery[]);
+    where(where: SQL | undefined): SQLiteEffectDeleteWithout<this, TDynamic, "where">;
+    orderBy(builder: (deleteTable: TTable) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): SQLiteEffectDeleteWithout<this, TDynamic, "orderBy">;
+    orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): SQLiteEffectDeleteWithout<this, TDynamic, "orderBy">;
+    limit(limit: number | Placeholder): SQLiteEffectDeleteWithout<this, TDynamic, "limit">;
+    returning(): SQLiteEffectDeleteReturningAll<this, TDynamic>;
+    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): SQLiteEffectDeleteReturning<this, TDynamic, TSelectedFields>;
+    /** @internal */
+    getSQL(): SQL;
+    toSQL(): Query;
+    /** @internal */
+    _prepare(isOneTimeQuery?: boolean): SQLiteEffectDeletePrepare<this, TEffectHKT>;
+    prepare(): SQLiteEffectDeletePrepare<this, TEffectHKT>;
+    run: ReturnType<this["prepare"]>["run"];
+    all: ReturnType<this["prepare"]>["all"];
+    get: ReturnType<this["prepare"]>["get"];
+    values: ReturnType<this["prepare"]>["values"];
+    execute: ReturnType<this["prepare"]>["execute"];
+    $dynamic(): SQLiteEffectDeleteDynamic<this>;
+}

package/dist/types/database/drizzle/sqlite-core/effect/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./count.js";
+export * from "./db.js";
+export * from "./delete.js";
+export * from "./insert.js";
+export * from "./query.js";
+export * from "./raw.js";
+export * from "./select.js";
+export * from "./session.js";
+export * from "./update.js";

package/dist/types/database/drizzle/sqlite-core/effect/insert.d.ts

@@ -0,0 +1,95 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { SelectResultFields } from "drizzle-orm/query-builders/select.types";
+import type { RunnableQuery } from "drizzle-orm/runnable-query";
+import type { Query, SQLWrapper } from "drizzle-orm/sql/sql";
+import { SQL } from "drizzle-orm/sql/sql";
+import type { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+import type { IndexColumn } from "drizzle-orm/sqlite-core/indexes";
+import type { SQLiteInsertConfig, SQLiteInsertSelectQueryBuilder, SQLiteInsertValue } from "drizzle-orm/sqlite-core/query-builders/insert";
+import type { SelectedFieldsFlat } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { PreparedQueryConfig } from "drizzle-orm/sqlite-core/session";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import type { Subquery } from "drizzle-orm/subquery";
+import { type DrizzleTypeError } from "drizzle-orm/utils";
+import { QueryBuilder } from "drizzle-orm/sqlite-core/query-builders/query-builder";
+import type { SQLiteUpdateSetSource } from "drizzle-orm/sqlite-core/query-builders/update";
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from "./session.js";
+export type SQLiteEffectInsertWithout<T extends AnySQLiteEffectInsert, TDynamic extends boolean, K extends keyof T & string> = TDynamic extends true ? T : Omit<SQLiteEffectInsertBase<T["_"]["table"], T["_"]["runResult"], T["_"]["returning"], TDynamic, T["_"]["excludedMethods"] | K, T["_"]["effectHKT"]>, T["_"]["excludedMethods"] | K>;
+export type SQLiteEffectInsertReturning<T extends AnySQLiteEffectInsert, TDynamic extends boolean, TSelectedFields extends SelectedFieldsFlat> = SQLiteEffectInsertWithout<SQLiteEffectInsertBase<T["_"]["table"], T["_"]["runResult"], SelectResultFields<TSelectedFields>, TDynamic, T["_"]["excludedMethods"], T["_"]["effectHKT"]>, TDynamic, "returning">;
+export type SQLiteEffectInsertReturningAll<T extends AnySQLiteEffectInsert, TDynamic extends boolean> = SQLiteEffectInsertWithout<SQLiteEffectInsertBase<T["_"]["table"], T["_"]["runResult"], T["_"]["table"]["$inferSelect"], TDynamic, T["_"]["excludedMethods"], T["_"]["effectHKT"]>, TDynamic, "returning">;
+export type SQLiteEffectInsertDynamic<T extends AnySQLiteEffectInsert> = SQLiteEffectInsert<T["_"]["table"], T["_"]["runResult"], T["_"]["returning"], T["_"]["effectHKT"]>;
+export type SQLiteEffectInsertOnConflictDoUpdateConfig<T extends AnySQLiteEffectInsert> = {
+    target: IndexColumn | IndexColumn[];
+    /** @deprecated - use either `targetWhere` or `setWhere` */
+    where?: SQL;
+    targetWhere?: SQL;
+    setWhere?: SQL;
+    set: SQLiteUpdateSetSource<T["_"]["table"]>;
+};
+export type SQLiteEffectInsertExecute<T extends AnySQLiteEffectInsert> = T["_"]["returning"] extends undefined ? T["_"]["runResult"] : T["_"]["returning"][];
+export type SQLiteEffectInsertPrepare<T extends AnySQLiteEffectInsert, TEffectHKT extends QueryEffectHKTBase = T["_"]["effectHKT"]> = SQLiteEffectPreparedQuery<PreparedQueryConfig & {
+    run: T["_"]["runResult"];
+    all: T["_"]["returning"] extends undefined ? DrizzleTypeError<".all() cannot be used without .returning()"> : T["_"]["returning"][];
+    get: T["_"]["returning"] extends undefined ? DrizzleTypeError<".get() cannot be used without .returning()"> : T["_"]["returning"];
+    values: T["_"]["returning"] extends undefined ? DrizzleTypeError<".values() cannot be used without .returning()"> : any[][];
+    execute: SQLiteEffectInsertExecute<T>;
+}, TEffectHKT>;
+export type SQLiteEffectInsert<TTable extends SQLiteTable = SQLiteTable, TRunResult = unknown, TReturning = any, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> = SQLiteEffectInsertBase<TTable, TRunResult, TReturning, true, never, TEffectHKT>;
+export type AnySQLiteEffectInsert = SQLiteEffectInsertBase<any, any, any, any, any, any>;
+export declare class SQLiteEffectInsertBuilder<in out TTable extends SQLiteTable, out TRunResult, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> {
+    protected table: TTable;
+    protected session: SQLiteEffectSession<TEffectHKT, TRunResult, any>;
+    protected dialect: SQLiteDialect;
+    private withList?;
+    static readonly [entityKind]: string;
+    constructor(table: TTable, session: SQLiteEffectSession<TEffectHKT, TRunResult, any>, dialect: SQLiteDialect, withList?: Subquery[] | undefined);
+    values(value: SQLiteInsertValue<TTable>): SQLiteEffectInsertBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    values(values: SQLiteInsertValue<TTable>[]): SQLiteEffectInsertBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    select(selectQuery: (qb: QueryBuilder) => SQLiteInsertSelectQueryBuilder<TTable>): SQLiteEffectInsertBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    select(selectQuery: (qb: QueryBuilder) => SQL): SQLiteEffectInsertBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    select(selectQuery: SQL): SQLiteEffectInsertBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+    select(selectQuery: SQLiteInsertSelectQueryBuilder<TTable>): SQLiteEffectInsertBase<TTable, TRunResult, undefined, false, never, TEffectHKT>;
+}
+export interface SQLiteEffectInsertBase<in out TTable extends SQLiteTable, out TRunResult, out TReturning = undefined, out TDynamic extends boolean = false, _TExcludedMethods extends string = never, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQLWrapper, RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], "sqlite">, Effect.Effect<TReturning extends undefined ? TRunResult : TReturning[], TEffectHKT["error"], TEffectHKT["context"]> {
+    readonly _: {
+        readonly dialect: "sqlite";
+        readonly table: TTable;
+        readonly resultType: "async";
+        readonly runResult: TRunResult;
+        readonly returning: TReturning;
+        readonly dynamic: TDynamic;
+        readonly excludedMethods: _TExcludedMethods;
+        readonly result: TReturning extends undefined ? TRunResult : TReturning[];
+        readonly effectHKT: TEffectHKT;
+    };
+}
+export declare class SQLiteEffectInsertBase<in out TTable extends SQLiteTable, out TRunResult, out TReturning = undefined, out TDynamic extends boolean = false, _TExcludedMethods extends string = never, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], "sqlite">, SQLWrapper {
+    private table;
+    private effectSession;
+    private effectDialect;
+    static readonly [entityKind]: string;
+    /** @internal */
+    config: SQLiteInsertConfig<TTable>;
+    constructor(table: TTable, values: SQLiteInsertConfig["values"], effectSession: SQLiteEffectSession<TEffectHKT, TRunResult, any>, effectDialect: SQLiteDialect, withList?: Subquery[], select?: boolean);
+    returning(): SQLiteEffectInsertReturningAll<this, TDynamic>;
+    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): SQLiteEffectInsertReturning<this, TDynamic, TSelectedFields>;
+    onConflictDoNothing(config?: {
+        target?: IndexColumn | IndexColumn[];
+        where?: SQL;
+    }): this;
+    onConflictDoUpdate(config: SQLiteEffectInsertOnConflictDoUpdateConfig<this>): this;
+    /** @internal */
+    getSQL(): SQL;
+    toSQL(): Query;
+    /** @internal */
+    _prepare(isOneTimeQuery?: boolean): SQLiteEffectInsertPrepare<this, TEffectHKT>;
+    prepare(): SQLiteEffectInsertPrepare<this, TEffectHKT>;
+    run: ReturnType<this["prepare"]>["run"];
+    all: ReturnType<this["prepare"]>["all"];
+    get: ReturnType<this["prepare"]>["get"];
+    values: ReturnType<this["prepare"]>["values"];
+    execute: ReturnType<this["prepare"]>["execute"];
+    $dynamic(): SQLiteEffectInsertDynamic<this>;
+}

package/dist/types/database/drizzle/sqlite-core/effect/query.d.ts

@@ -0,0 +1,63 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { type BuildQueryResult, type DBQueryConfig, type TableRelationalConfig, type TablesRelationalConfig } from "drizzle-orm/relations";
+import type { RunnableQuery } from "drizzle-orm/runnable-query";
+import { type Query, type SQL, type SQLWrapper } from "drizzle-orm/sql/sql";
+import type { KnownKeysOnly } from "drizzle-orm/utils";
+import type { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+import type { PreparedQueryConfig } from "drizzle-orm/sqlite-core/session";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from "./session.js";
+export declare class SQLiteEffectRelationalQueryBuilder<out TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> {
+    private schema;
+    private table;
+    private tableConfig;
+    private dialect;
+    private session;
+    private rowMode?;
+    private forbidJsonb?;
+    static readonly [entityKind]: string;
+    constructor(schema: TSchema, table: SQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteEffectSession<TEffectHKT, any, any>, rowMode?: boolean | undefined, forbidJsonb?: boolean | undefined);
+    findMany<TConfig extends DBQueryConfig<"many", TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<"many", TSchema, TFields>>): SQLiteEffectRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[], TEffectHKT>;
+    findFirst<TConfig extends DBQueryConfig<"one", TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<"one", TSchema, TFields>>): SQLiteEffectRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig> | undefined, TEffectHKT>;
+}
+export interface SQLiteEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends Effect.Effect<TResult, TEffectHKT["error"], TEffectHKT["context"]>, RunnableQuery<TResult, "sqlite">, SQLWrapper {
+}
+export declare class SQLiteEffectRelationalQuery<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> implements RunnableQuery<TResult, "sqlite">, SQLWrapper {
+    private schema;
+    private tableConfig;
+    private dialect;
+    private session;
+    private config;
+    private rowMode?;
+    private forbidJsonb?;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly dialect: "sqlite";
+        readonly type: "async";
+        readonly result: TResult;
+    };
+    /** @internal */
+    mode: "many" | "first";
+    /** @internal */
+    table: SQLiteTable;
+    constructor(schema: TablesRelationalConfig, table: SQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteEffectSession<TEffectHKT, any, any>, config: DBQueryConfig<"many" | "one"> | true, mode: "many" | "first", rowMode?: boolean | undefined, forbidJsonb?: boolean | undefined);
+    /** @internal */
+    getSQL(): SQL;
+    /** @internal */
+    _prepare(isOneTimeQuery?: boolean): SQLiteEffectPreparedQuery<PreparedQueryConfig & {
+        all: TResult;
+        get: TResult;
+        execute: TResult;
+    }, TEffectHKT, true>;
+    prepare(): SQLiteEffectPreparedQuery<PreparedQueryConfig & {
+        all: TResult;
+        get: TResult;
+        execute: TResult;
+    }, TEffectHKT, true>;
+    private _getQuery;
+    private _toSQL;
+    toSQL(): Query;
+    execute(placeholderValues?: Record<string, unknown>): import("drizzle-orm/effect-core").QueryEffectKind<TEffectHKT, TResult>;
+}

package/dist/types/database/drizzle/sqlite-core/effect/raw.d.ts

@@ -0,0 +1,32 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { RunnableQuery } from "drizzle-orm/runnable-query";
+import type { PreparedQuery } from "drizzle-orm/session";
+import type { Query, SQL, SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+type SQLiteEffectRawAction = "all" | "get" | "values" | "run";
+export interface SQLiteEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends Effect.Effect<TResult, TEffectHKT["error"], TEffectHKT["context"]>, RunnableQuery<TResult, "sqlite">, SQLWrapper {
+}
+export declare class SQLiteEffectRaw<TResult, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> implements RunnableQuery<TResult, "sqlite">, SQLWrapper, PreparedQuery {
+    execute: () => Effect.Effect<TResult, TEffectHKT["error"], TEffectHKT["context"]>;
+    /** @internal */
+    getSQL: () => SQL;
+    private action;
+    private dialect;
+    private mapBatchResult;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly dialect: "sqlite";
+        readonly result: TResult;
+    };
+    constructor(execute: () => Effect.Effect<TResult, TEffectHKT["error"], TEffectHKT["context"]>, 
+    /** @internal */
+    getSQL: () => SQL, action: SQLiteEffectRawAction, dialect: SQLiteAsyncDialect, mapBatchResult: (result: unknown) => unknown);
+    getQuery(): Query & {
+        method: SQLiteEffectRawAction;
+    };
+    mapResult(result: unknown, isFromBatch?: boolean): unknown;
+    _prepare(): PreparedQuery;
+}
+export {};

package/dist/types/database/drizzle/sqlite-core/effect/select.d.ts

@@ -0,0 +1,64 @@
+import type * as Effect from "effect/Effect";
+import type { CacheConfig } from "drizzle-orm/cache/core/types";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from "drizzle-orm/query-builders/select.types";
+import { SQL } from "drizzle-orm/sql/sql";
+import type { ColumnsSelection, SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+import { SQLiteSelectQueryBuilderBase } from "drizzle-orm/sqlite-core/query-builders/select";
+import type { CreateSQLiteSelectFromBuilderMode, SelectedFields, SQLiteSelectHKTBase } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { type Assume } from "drizzle-orm/utils";
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from "./session.js";
+export type SQLiteEffectSelectPrepare<T extends AnySQLiteEffectSelect, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> = SQLiteEffectPreparedQuery<{
+    type: "async";
+    run: T["_"]["runResult"];
+    all: T["_"]["result"];
+    get: T["_"]["result"][number] | undefined;
+    values: any[][];
+    execute: T["_"]["result"];
+}, TEffectHKT>;
+export declare class SQLiteEffectSelectBuilder<out TSelection extends SelectedFields | undefined, out TRunResult, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase, out TBuilderMode extends "db" | "qb" = "db"> {
+    static readonly [entityKind]: string;
+    private fields;
+    private session;
+    private dialect;
+    private withList;
+    private distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: SQLiteEffectSession<TEffectHKT, TRunResult, any> | undefined;
+        dialect: SQLiteDialect;
+        withList?: Subquery[];
+        distinct?: boolean;
+    });
+    from<TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL>(source: TFrom): TBuilderMode extends "db" ? SQLiteEffectSelectBase<GetSelectTableName<TFrom>, TRunResult, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? "single" : "partial", GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, "not-null"> : {}, false, never, SelectResult<TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? "single" : "partial", GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, "not-null"> : {}>[], BuildSubquerySelection<TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, "not-null"> : {}>, TEffectHKT> : CreateSQLiteSelectFromBuilderMode<TBuilderMode, GetSelectTableName<TFrom>, "async", TRunResult, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? "single" : "partial">;
+}
+export interface SQLiteEffectSelectHKT<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQLiteSelectHKTBase {
+    _type: SQLiteEffectSelectBase<this["tableName"], this["runResult"], Assume<this["selection"], ColumnsSelection>, this["selectMode"], Assume<this["nullabilityMap"], Record<string, JoinNullability>>, this["dynamic"], this["excludedMethods"], Assume<this["result"], any[]>, Assume<this["selectedFields"], ColumnsSelection>, TEffectHKT>;
+}
+export interface SQLiteEffectSelectBase<out TTableName extends string | undefined, out TRunResult, out TSelection extends ColumnsSelection, out TSelectMode extends SelectMode = "single", out TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, "not-null"> : {}, out TDynamic extends boolean = false, TExcludedMethods extends string = never, out TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], out TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQLiteSelectQueryBuilderBase<SQLiteEffectSelectHKT<TEffectHKT>, TTableName, "async", TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields>, Effect.Effect<TResult, TEffectHKT["error"], TEffectHKT["context"]> {
+}
+export declare class SQLiteEffectSelectBase<out TTableName extends string | undefined, out TRunResult, out TSelection extends ColumnsSelection, out TSelectMode extends SelectMode = "single", out TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, "not-null"> : {}, out TDynamic extends boolean = false, TExcludedMethods extends string = never, out TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], out TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQLiteSelectQueryBuilderBase<SQLiteEffectSelectHKT<TEffectHKT>, TTableName, "async", TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields> implements SQLWrapper {
+    static readonly [entityKind]: string;
+    private get effectConfig();
+    /** @internal */
+    getSQL(): SQL;
+    /** @internal */
+    _prepare(isOneTimeQuery?: boolean): SQLiteEffectSelectPrepare<this, TEffectHKT>;
+    $withCache(config?: {
+        config?: CacheConfig;
+        tag?: string;
+        autoInvalidate?: boolean;
+    } | false): this;
+    prepare(): SQLiteEffectSelectPrepare<this, TEffectHKT>;
+    run: ReturnType<this["prepare"]>["run"];
+    all: ReturnType<this["prepare"]>["all"];
+    get: ReturnType<this["prepare"]>["get"];
+    values: ReturnType<this["prepare"]>["values"];
+    execute: ReturnType<this["prepare"]>["execute"];
+}
+export type AnySQLiteEffectSelect = SQLiteEffectSelectBase<any, any, any, any, any, any, any, any, any, any>;

package/dist/types/database/drizzle/sqlite-core/effect/session.d.ts

@@ -0,0 +1,88 @@
+import * as Effect from "effect/Effect";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import type { EffectCacheShape } from "drizzle-orm/cache/core/cache-effect";
+import type { WithCacheConfig } from "drizzle-orm/cache/core/types";
+import { MigratorInitError } from "drizzle-orm/effect-core/errors";
+import { EffectTransactionRollbackError } from "drizzle-orm/effect-core/errors";
+import type { EffectLoggerShape } from "drizzle-orm/effect-core/logger";
+import type { QueryEffectHKTBase, QueryEffectKind } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { MigrationConfig, MigrationMeta } from "drizzle-orm/migrator";
+import type { AnyRelations, EmptyRelations, RelationalQueryMapperConfig } from "drizzle-orm/relations";
+import type { PreparedQuery } from "drizzle-orm/session";
+import { type Query, type SQL } from "drizzle-orm/sql/sql";
+import type { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { PreparedQueryConfig, SQLiteExecuteMethod, SQLiteTransactionConfig } from "drizzle-orm/sqlite-core/session";
+import { SQLiteEffectDatabase } from "./db.js";
+type MigrationConfigWithInit = MigrationConfig & {
+    init?: boolean;
+};
+type SQLiteEffectExecuteMethod = SQLiteExecuteMethod | "values";
+export declare class SQLiteEffectPreparedQuery<T extends PreparedQueryConfig, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase, TIsRqbV2 extends boolean = false> implements PreparedQuery {
+    private executor;
+    protected query: Query;
+    private logger;
+    private cache;
+    private queryMetadata;
+    private fields;
+    private useJitMappers;
+    private customResultMapper?;
+    private isRqbV2Query?;
+    private rqbConfig?;
+    private isInTransaction;
+    static readonly [entityKind]: string;
+    /** @internal */
+    joinsNotNullableMap?: Record<string, boolean>;
+    private jitMapper?;
+    private cacheConfig;
+    private effectExecuteMethod;
+    constructor(executor: (params: unknown[], executeMethod: SQLiteEffectExecuteMethod) => Effect.Effect<unknown, unknown, unknown>, query: Query, logger: EffectLoggerShape, cache: EffectCacheShape, queryMetadata: {
+        type: "select" | "update" | "delete" | "insert";
+        tables: string[];
+    } | undefined, cacheConfig: WithCacheConfig | undefined, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, useJitMappers: boolean | undefined, customResultMapper?: ((rows: TIsRqbV2 extends true ? Record<string, unknown>[] : unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown) | undefined, isRqbV2Query?: TIsRqbV2 | undefined, rqbConfig?: RelationalQueryMapperConfig | undefined, isInTransaction?: Effect.Effect<boolean>);
+    run(placeholderValues?: Record<string, unknown>): QueryEffectKind<TEffectHKT, T["run"]>;
+    all(placeholderValues?: Record<string, unknown>): QueryEffectKind<TEffectHKT, T["all"]>;
+    get(placeholderValues?: Record<string, unknown>): QueryEffectKind<TEffectHKT, T["get"]>;
+    values(placeholderValues?: Record<string, unknown>): QueryEffectKind<TEffectHKT, T["values"]>;
+    execute(placeholderValues?: Record<string, unknown>): QueryEffectKind<TEffectHKT, T["execute"]>;
+    mapRunResult(result: unknown, _isFromBatch?: boolean): unknown;
+    mapAllResult(rows: unknown, isFromBatch?: boolean): unknown;
+    mapGetResult(rows: unknown, isFromBatch?: boolean): unknown;
+    private allRqbV2;
+    private getRqbV2;
+    private executeWithCache;
+    private mapCachedResult;
+    private queryWithCache;
+    getQuery(): Query;
+    mapResult(response: unknown, isFromBatch?: boolean): unknown;
+}
+export declare abstract class SQLiteEffectSession<out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase, out TRunResult = unknown, out TRelations extends AnyRelations = EmptyRelations> {
+    readonly dialect: SQLiteAsyncDialect;
+    static readonly [entityKind]: string;
+    constructor(dialect: SQLiteAsyncDialect);
+    abstract prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown, queryMetadata?: {
+        type: "select" | "update" | "delete" | "insert";
+        tables: string[];
+    }, cacheConfig?: WithCacheConfig): SQLiteEffectPreparedQuery<T, TEffectHKT>;
+    prepareOneTimeQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown, queryMetadata?: {
+        type: "select" | "update" | "delete" | "insert";
+        tables: string[];
+    }, cacheConfig?: WithCacheConfig): SQLiteEffectPreparedQuery<T, TEffectHKT>;
+    abstract prepareRelationalQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper: (rows: Record<string, unknown>[], mapColumnValue?: (value: unknown) => unknown) => unknown, config: RelationalQueryMapperConfig): SQLiteEffectPreparedQuery<T, TEffectHKT, true>;
+    prepareOneTimeRelationalQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper: (rows: Record<string, unknown>[], mapColumnValue?: (value: unknown) => unknown) => unknown, config: RelationalQueryMapperConfig): SQLiteEffectPreparedQuery<T, TEffectHKT, true>;
+    run(query: SQL): QueryEffectKind<TEffectHKT, TRunResult>;
+    all<T = unknown>(query: SQL): QueryEffectKind<TEffectHKT, T[]>;
+    get<T = unknown>(query: SQL): QueryEffectKind<TEffectHKT, T | undefined>;
+    values<T extends unknown[] = unknown[]>(query: SQL): QueryEffectKind<TEffectHKT, T[]>;
+    count(query: SQL): QueryEffectKind<TEffectHKT, number>;
+    abstract transaction<A, E, R>(transaction: (tx: SQLiteEffectTransaction<TEffectHKT, TRunResult, TRelations>) => Effect.Effect<A, E, R>, config?: SQLiteTransactionConfig): Effect.Effect<A, E | SqlError, R>;
+}
+export declare abstract class SQLiteEffectTransaction<out TEffectHKT extends QueryEffectHKTBase, out TRunResult, out TRelations extends AnyRelations = EmptyRelations> extends SQLiteEffectDatabase<TEffectHKT, TRunResult, TRelations> {
+    protected relations: TRelations;
+    static readonly [entityKind]: string;
+    constructor(dialect: SQLiteAsyncDialect, session: SQLiteEffectSession<TEffectHKT, TRunResult, TRelations>, relations: TRelations);
+    rollback(): EffectTransactionRollbackError;
+}
+export declare const migrate: <TEffectHKT extends QueryEffectHKTBase>(migrations: MigrationMeta[], session: SQLiteEffectSession<TEffectHKT, unknown, EmptyRelations>, config: string | MigrationConfigWithInit) => Effect.Effect<undefined, import("drizzle-orm/effect-core").EffectDrizzleError | SqlError | MigratorInitError | TEffectHKT["error"], TEffectHKT["context"]>;
+export {};

package/dist/types/database/drizzle/sqlite-core/effect/update.d.ts

@@ -0,0 +1,90 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { SelectResultFields } from "drizzle-orm/query-builders/select.types";
+import type { RunnableQuery } from "drizzle-orm/runnable-query";
+import type { Placeholder, Query, SQL, SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteDialect } from "drizzle-orm/sqlite-core/dialect";
+import type { SelectedFields } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { SQLiteUpdateConfig, SQLiteUpdateSetSource } from "drizzle-orm/sqlite-core/query-builders/update";
+import type { PreparedQueryConfig } from "drizzle-orm/sqlite-core/session";
+import { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import { SQLiteViewBase } from "drizzle-orm/sqlite-core/view-base";
+import { Subquery } from "drizzle-orm/subquery";
+import { type DrizzleTypeError, type UpdateSet, type ValueOrArray } from "drizzle-orm/utils";
+import type { SQLiteColumn } from "drizzle-orm/sqlite-core/columns/common";
+import type { SQLiteEffectPreparedQuery, SQLiteEffectSession } from "./session.js";
+export type SQLiteEffectUpdateWithout<T extends AnySQLiteEffectUpdate, TDynamic extends boolean, K extends keyof T & string> = TDynamic extends true ? T : Omit<SQLiteEffectUpdateBase<T["_"]["table"], T["_"]["runResult"], T["_"]["from"], T["_"]["returning"], TDynamic, T["_"]["excludedMethods"] | K, T["_"]["effectHKT"]>, T["_"]["excludedMethods"] | K>;
+export type SQLiteEffectUpdateWithJoins<T extends AnySQLiteEffectUpdate, TDynamic extends boolean, TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL> = TDynamic extends true ? T : Omit<SQLiteEffectUpdateBase<T["_"]["table"], T["_"]["runResult"], TFrom, T["_"]["returning"], TDynamic, Exclude<T["_"]["excludedMethods"] | "from", "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">, T["_"]["effectHKT"]>, Exclude<T["_"]["excludedMethods"] | "from", "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">>;
+export type SQLiteEffectUpdateReturningAll<T extends AnySQLiteEffectUpdate, TDynamic extends boolean> = SQLiteEffectUpdateWithout<SQLiteEffectUpdateBase<T["_"]["table"], T["_"]["runResult"], T["_"]["from"], T["_"]["table"]["$inferSelect"], TDynamic, T["_"]["excludedMethods"], T["_"]["effectHKT"]>, TDynamic, "returning">;
+export type SQLiteEffectUpdateReturning<T extends AnySQLiteEffectUpdate, TDynamic extends boolean, TSelectedFields extends SelectedFields> = SQLiteEffectUpdateWithout<SQLiteEffectUpdateBase<T["_"]["table"], T["_"]["runResult"], T["_"]["from"], SelectResultFields<TSelectedFields>, TDynamic, T["_"]["excludedMethods"], T["_"]["effectHKT"]>, TDynamic, "returning">;
+export type SQLiteEffectUpdateExecute<T extends AnySQLiteEffectUpdate> = T["_"]["returning"] extends undefined ? T["_"]["runResult"] : T["_"]["returning"][];
+export type SQLiteEffectUpdatePrepare<T extends AnySQLiteEffectUpdate, TEffectHKT extends QueryEffectHKTBase = T["_"]["effectHKT"]> = SQLiteEffectPreparedQuery<PreparedQueryConfig & {
+    run: T["_"]["runResult"];
+    all: T["_"]["returning"] extends undefined ? DrizzleTypeError<".all() cannot be used without .returning()"> : T["_"]["returning"][];
+    get: T["_"]["returning"] extends undefined ? DrizzleTypeError<".get() cannot be used without .returning()"> : T["_"]["returning"];
+    values: T["_"]["returning"] extends undefined ? DrizzleTypeError<".values() cannot be used without .returning()"> : any[][];
+    execute: SQLiteEffectUpdateExecute<T>;
+}, TEffectHKT>;
+export type SQLiteEffectUpdateDynamic<T extends AnySQLiteEffectUpdate> = SQLiteEffectUpdate<T["_"]["table"], T["_"]["runResult"], T["_"]["from"], T["_"]["returning"], T["_"]["effectHKT"]>;
+export type SQLiteEffectUpdate<TTable extends SQLiteTable = SQLiteTable, TRunResult = unknown, TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined, TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined, TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> = SQLiteEffectUpdateBase<TTable, TRunResult, TFrom, TReturning, true, never, TEffectHKT>;
+export type AnySQLiteEffectUpdate = SQLiteEffectUpdateBase<any, any, any, any, any, any, any>;
+export type SQLiteEffectUpdateJoinFn<T extends AnySQLiteEffectUpdate> = <TJoinedTable extends SQLiteTable | Subquery | SQLiteViewBase | SQL>(table: TJoinedTable, on: ((updateTable: T["_"]["table"]["_"]["columns"], from: T["_"]["from"] extends SQLiteTable ? T["_"]["from"]["_"]["columns"] : T["_"]["from"] extends Subquery | SQLiteViewBase ? T["_"]["from"]["_"]["selectedFields"] : never) => SQL | undefined) | SQL | undefined) => T;
+export declare class SQLiteEffectUpdateBuilder<in out TTable extends SQLiteTable, out TRunResult, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> {
+    protected table: TTable;
+    protected session: SQLiteEffectSession<TEffectHKT, TRunResult, any>;
+    protected dialect: SQLiteDialect;
+    private withList?;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    constructor(table: TTable, session: SQLiteEffectSession<TEffectHKT, TRunResult, any>, dialect: SQLiteDialect, withList?: Subquery[] | undefined);
+    set(values: SQLiteUpdateSetSource<TTable>): SQLiteEffectUpdateWithout<SQLiteEffectUpdateBase<TTable, TRunResult, undefined, undefined, false, never, TEffectHKT>, false, "leftJoin" | "rightJoin" | "innerJoin" | "fullJoin">;
+}
+export interface SQLiteEffectUpdateBase<out TTable extends SQLiteTable = SQLiteTable, out TRunResult = unknown, out TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined, out TReturning = undefined, out TDynamic extends boolean = false, _TExcludedMethods extends string = never, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQLWrapper, RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], "sqlite">, Effect.Effect<TReturning extends undefined ? TRunResult : TReturning[], TEffectHKT["error"], TEffectHKT["context"]> {
+    readonly _: {
+        readonly dialect: "sqlite";
+        readonly table: TTable;
+        readonly resultType: "async";
+        readonly runResult: TRunResult;
+        readonly from: TFrom;
+        readonly returning: TReturning;
+        readonly dynamic: TDynamic;
+        readonly excludedMethods: _TExcludedMethods;
+        readonly result: TReturning extends undefined ? TRunResult : TReturning[];
+        readonly effectHKT: TEffectHKT;
+    };
+}
+export declare class SQLiteEffectUpdateBase<out TTable extends SQLiteTable = SQLiteTable, out TRunResult = unknown, out TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL | undefined = undefined, out TReturning = undefined, out TDynamic extends boolean = false, _TExcludedMethods extends string = never, out TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> implements RunnableQuery<TReturning extends undefined ? TRunResult : TReturning[], "sqlite">, SQLWrapper {
+    private effectSession;
+    private effectDialect;
+    static readonly [entityKind]: string;
+    /** @internal */
+    config: SQLiteUpdateConfig;
+    constructor(table: TTable, set: UpdateSet, effectSession: SQLiteEffectSession<TEffectHKT, TRunResult, any>, effectDialect: SQLiteDialect, withList?: Subquery[]);
+    from<TFrom extends SQLiteTable | Subquery | SQLiteViewBase | SQL>(source: TFrom): SQLiteEffectUpdateWithJoins<this, TDynamic, TFrom>;
+    private createJoin;
+    leftJoin: SQLiteEffectUpdateJoinFn<this>;
+    rightJoin: SQLiteEffectUpdateJoinFn<this>;
+    innerJoin: SQLiteEffectUpdateJoinFn<this>;
+    fullJoin: SQLiteEffectUpdateJoinFn<this>;
+    where(where: SQL | undefined): SQLiteEffectUpdateWithout<this, TDynamic, "where">;
+    orderBy(builder: (updateTable: TTable) => ValueOrArray<SQLiteColumn | SQL | SQL.Aliased>): SQLiteEffectUpdateWithout<this, TDynamic, "orderBy">;
+    orderBy(...columns: (SQLiteColumn | SQL | SQL.Aliased)[]): SQLiteEffectUpdateWithout<this, TDynamic, "orderBy">;
+    limit(limit: number | Placeholder): SQLiteEffectUpdateWithout<this, TDynamic, "limit">;
+    returning(): SQLiteEffectUpdateReturningAll<this, TDynamic>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): SQLiteEffectUpdateReturning<this, TDynamic, TSelectedFields>;
+    /** @internal */
+    getSQL(): SQL;
+    toSQL(): Query;
+    /** @internal */
+    _prepare(isOneTimeQuery?: boolean): SQLiteEffectUpdatePrepare<this, TEffectHKT>;
+    prepare(): SQLiteEffectUpdatePrepare<this, TEffectHKT>;
+    run: ReturnType<this["prepare"]>["run"];
+    all: ReturnType<this["prepare"]>["all"];
+    get: ReturnType<this["prepare"]>["get"];
+    values: ReturnType<this["prepare"]>["values"];
+    execute: ReturnType<this["prepare"]>["execute"];
+    $dynamic(): SQLiteEffectUpdateDynamic<this>;
+}