@opencode-ai/core 0.0.0-next-17293

package/dist/types/credential.d.ts

@@ -0,0 +1,82 @@
+export * as Credential from "./credential.js";
+import { Context, Effect, Schema } from "effect";
+import { Credential } from "@opencode-ai/schema/credential";
+import { Integration } from "@opencode-ai/schema/integration";
+export declare const ID: Schema.brand<Schema.String, "Credential.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+};
+export type ID = Credential.ID;
+export declare const OAuth: Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export type OAuth = Credential.OAuth;
+export declare const Key: Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>;
+export type Key = Credential.Key;
+export declare const Value: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+    readonly refresh: Schema.String;
+    readonly access: Schema.String;
+    readonly expires: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"key">;
+    readonly key: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+}>]>;
+export type Value = Credential.Value;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Credential.ID">;
+    };
+    readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+    readonly label: Schema.String;
+    readonly value: Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"oauth">;
+        readonly methodID: Schema.brand<Schema.String, "Integration.MethodID">;
+        readonly refresh: Schema.String;
+        readonly access: Schema.String;
+        readonly expires: Schema.Int;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"key">;
+        readonly key: Schema.String;
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly configuration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+    }>]>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export interface Interface {
+    /** Returns every stored credential. */
+    readonly all: () => Effect.Effect<Info[]>;
+    /** Returns stored credentials belonging to one integration. */
+    readonly list: (integrationID: Integration.ID) => Effect.Effect<Info[]>;
+    /** Returns one stored credential by ID. */
+    readonly get: (id: ID) => Effect.Effect<Info | undefined>;
+    /** Replaces any credential for an integration and returns the new record. */
+    readonly create: (input: {
+        readonly integrationID: Integration.ID;
+        readonly value: Value;
+        readonly label?: string;
+    }) => Effect.Effect<Info>;
+    /** Updates the label or secret value of a stored credential. */
+    readonly update: (id: ID, updates: Partial<Pick<Info, "label" | "value">>) => Effect.Effect<void>;
+    /** Removes a stored credential. */
+    readonly remove: (id: ID) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Credential", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

package/dist/types/database/database.d.ts

@@ -0,0 +1,23 @@
+export * as Database from "./database.js";
+import { EffectDrizzleSqlite } from "./drizzle.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import { Global } from "@opencode-ai/util/global";
+declare const makeDatabase: Effect.Effect<EffectDrizzleSqlite.EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+    $client: SqlClient.SqlClient;
+}, never, SqlClient.SqlClient>;
+type DatabaseShape = Effect.Success<typeof makeDatabase>;
+export interface Interface {
+    db: DatabaseShape;
+}
+export declare const Options: Schema.Struct<{
+    readonly path: Schema.optional<Schema.String>;
+}>;
+export type Options = typeof Options.Type;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/storage/Database", Interface>;
+export declare class Service extends Service_base {
+}
+export declare function layer(options?: Options): Layer.Layer<Service, never, Global.Service>;
+export declare const layerFromClient: Layer.Layer<Service, never, SqlClient.SqlClient | Global.Service>;
+export declare function configured(options?: Options): import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;
+export declare const node: import("@opencode-ai/util/effect/layer-node").Node<Service, never, import("@opencode-ai/util/effect/layer-node").Tag<"global">>;

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

@@ -0,0 +1,43 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { EffectCache } from "drizzle-orm/cache/core/cache-effect";
+import { EffectLogger } from "drizzle-orm/effect-core";
+import { entityKind } from "drizzle-orm/entity";
+import type { AnyRelations, EmptyRelations } from "drizzle-orm/relations";
+import { SQLiteEffectDatabase } from "../sqlite-core/effect/db.js";
+import type { DrizzleConfig } from "drizzle-orm/utils";
+import { type EffectSQLiteQueryEffectHKT, type EffectSQLiteRunResult } from "./session.js";
+export declare class EffectSQLiteDatabase<TRelations extends AnyRelations = EmptyRelations> extends SQLiteEffectDatabase<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations> {
+    static readonly [entityKind]: string;
+}
+export type EffectDrizzleSQLiteConfig<TRelations extends AnyRelations = EmptyRelations> = Omit<DrizzleConfig<Record<string, never>, TRelations>, "cache" | "logger" | "schema">;
+export declare const DefaultServices: Layer.Layer<EffectCache | EffectLogger, never, never>;
+/**
+ * Creates an EffectSQLiteDatabase instance.
+ *
+ * Requires a generic Effect `SqlClient`, `EffectLogger`, and `EffectCache` services to be provided.
+ * Drizzle only depends on the generic `SqlClient`; install and provide a compatible SQLite provider such as
+ * `@effect/sql-sqlite-node`, `@effect/sql-sqlite-bun`, or another package that exposes `SqlClient`.
+ *
+ * @example
+ * ```ts
+ * import { SqliteClient } from '@effect/sql-sqlite-node';
+ * import * as SQLiteDrizzle from 'drizzle-orm/effect-sqlite';
+ * import * as Effect from 'effect/Effect';
+ *
+ * const db = yield* SQLiteDrizzle.make({ relations }).pipe(
+ *   Effect.provide(SQLiteDrizzle.DefaultServices),
+ *   Effect.provide(SqliteClient.layer({ filename: 'sqlite.db' })),
+ * );
+ * ```
+ */
+export declare const make: <TRelations extends AnyRelations = EmptyRelations>(config?: EffectDrizzleSQLiteConfig<TRelations> | undefined) => Effect.Effect<EffectSQLiteDatabase<TRelations> & {
+    $client: SqlClient;
+}, never, SqlClient | EffectCache | EffectLogger>;
+/**
+ * Convenience function that creates an EffectSQLiteDatabase with `DefaultServices` already provided.
+ */
+export declare const makeWithDefaults: <TRelations extends AnyRelations = EmptyRelations>(config?: EffectDrizzleSQLiteConfig<TRelations>) => Effect.Effect<EffectSQLiteDatabase<TRelations> & {
+    $client: SqlClient;
+}, never, SqlClient>;

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

@@ -0,0 +1,3 @@
+export { EffectLogger } from "drizzle-orm/effect-core";
+export * from "./driver.js";
+export * from "./session.js";

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

@@ -0,0 +1,4 @@
+import type { MigrationConfig } from "drizzle-orm/migrator";
+import type { AnyRelations } from "drizzle-orm/relations";
+import type { EffectSQLiteDatabase } from "./driver.js";
+export declare function migrate<TRelations extends AnyRelations>(db: EffectSQLiteDatabase<TRelations>, config: MigrationConfig): import("effect/Effect").Effect<undefined, import("drizzle-orm/effect-core").EffectDrizzleError | import("effect/unstable/sql/SqlError").SqlError | import("drizzle-orm/effect-core").EffectDrizzleQueryError | import("drizzle-orm/effect-core").MigratorInitError, never>;

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

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+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 type { EffectDrizzleQueryError } from "drizzle-orm/effect-core/errors";
+import type { EffectLoggerShape } from "drizzle-orm/effect-core/logger";
+import type { QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import type { AnyRelations } from "drizzle-orm/relations";
+import type { RelationalQueryMapperConfig } from "drizzle-orm/relations";
+import type { Query } from "drizzle-orm/sql/sql";
+import type { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core/dialect";
+import { SQLiteEffectPreparedQuery, SQLiteEffectSession, SQLiteEffectTransaction } from "../sqlite-core/effect/session.js";
+import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { PreparedQueryConfig, SQLiteExecuteMethod, SQLiteTransactionConfig } from "drizzle-orm/sqlite-core/session";
+export interface EffectSQLiteQueryEffectHKT extends QueryEffectHKTBase {
+    readonly error: EffectDrizzleQueryError;
+    readonly context: never;
+}
+export type EffectSQLiteRunResult = readonly never[];
+export interface EffectSQLiteSessionOptions {
+    logger: EffectLoggerShape;
+    cache: EffectCacheShape;
+    useJitMappers?: boolean;
+}
+export declare class EffectSQLiteSession<TRelations extends AnyRelations> extends SQLiteEffectSession<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations> {
+    private client;
+    protected relations: TRelations;
+    private options;
+    static readonly [entityKind]: string;
+    constructor(client: SqlClient, dialect: SQLiteAsyncDialect, relations: TRelations, options: EffectSQLiteSessionOptions);
+    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, EffectSQLiteQueryEffectHKT>;
+    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, EffectSQLiteQueryEffectHKT, true>;
+    private execute;
+    private isInTransaction;
+    private executeTransactionStatement;
+    private withTransaction;
+    transaction<A, E, R>(transaction: (tx: EffectSQLiteTransaction<TRelations>) => Effect.Effect<A, E, R>, config?: SQLiteTransactionConfig): Effect.Effect<A, E | SqlError, R>;
+}
+export declare class EffectSQLiteTransaction<TRelations extends AnyRelations> extends SQLiteEffectTransaction<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations> {
+    static readonly [entityKind]: string;
+    transaction: <A, E, R>(transaction: (tx: SQLiteEffectTransaction<EffectSQLiteQueryEffectHKT, EffectSQLiteRunResult, TRelations>) => Effect.Effect<A, E, R>) => Effect.Effect<A, SqlError | E, R>;
+}

package/dist/types/database/drizzle/index.d.ts

@@ -0,0 +1,5 @@
+export { EffectLogger } from "drizzle-orm/effect-core";
+export * from "./effect-sqlite/driver.js";
+export * from "./effect-sqlite/session.js";
+export { migrate } from "./effect-sqlite/migrator.js";
+export * as EffectDrizzleSqlite from "./index.js";

package/dist/types/database/drizzle/internal/drizzle-utils.d.ts

@@ -0,0 +1,20 @@
+import { Column } from "drizzle-orm/column";
+import type { JoinNullability } from "drizzle-orm/query-builders/select.types";
+import { SQL } from "drizzle-orm/sql/sql";
+import type { SelectedFieldsOrdered } from "drizzle-orm/sqlite-core/query-builders/select.types";
+import type { SQLiteUpdateSetSource } from "drizzle-orm/sqlite-core/query-builders/update";
+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 { UpdateSet } from "drizzle-orm/utils";
+export declare function getTableColumnsRuntime(table: SQLiteTable): Record<string, Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnType>, object>>;
+export declare function getViewSelectedFieldsRuntime(view: SQLiteViewBase): {
+    selectedFields: Record<string, unknown>;
+    name: string;
+};
+export declare function jitCompatCheck(isEnabled: boolean | undefined): boolean;
+export declare function orderSelectedFields<TColumn extends Column>(fields: Record<string, unknown>, pathPrefix?: string[]): SelectedFieldsOrdered;
+export declare function mapUpdateSet<TTable extends SQLiteTable>(table: TTable, values: SQLiteUpdateSetSource<TTable>): UpdateSet;
+export declare function mapResultRow(columns: SelectedFieldsOrdered, row: unknown[], joinsNotNullableMap: Record<string, boolean> | undefined): Record<string, unknown>;
+export declare function getTableLikeName(table: SQLiteTable | Subquery | SQLiteViewBase | SQL): string | undefined;
+export type { JoinNullability };

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

@@ -0,0 +1,20 @@
+import type * as Effect from "effect/Effect";
+import { type QueryEffectHKTBase } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import { SQL, type SQLWrapper } from "drizzle-orm/sql/sql";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core/table";
+import type { SQLiteView } from "drizzle-orm/sqlite-core/view";
+import type { SQLiteEffectSession } from "./session.js";
+export interface SQLiteEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQL<number>, SQLWrapper<number>, Effect.Effect<number, TEffectHKT["error"], TEffectHKT["context"]> {
+}
+export declare class SQLiteEffectCountBuilder<TEffectHKT extends QueryEffectHKTBase = QueryEffectHKTBase> extends SQL<number> {
+    static readonly [entityKind]: string;
+    private sql;
+    private session;
+    constructor(params: {
+        source: SQLiteTable | SQLiteView | SQL | SQLWrapper;
+        filters?: SQL<unknown>;
+        session: SQLiteEffectSession<TEffectHKT, any, any>;
+    });
+    execute(placeholderValues?: Record<string, unknown>): import("drizzle-orm/effect-core").QueryEffectKind<TEffectHKT, number>;
+}

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

@@ -0,0 +1,82 @@
+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 SQLiteEffectWithReplicas<Q> = Q & {
+    $primary: Q;
+    $replicas: Q[];
+};
+export declare const withReplicas: <TEffectHKT extends QueryEffectHKTBase, TRunResult, TRelations extends AnyRelations, Q extends SQLiteEffectDatabase<TEffectHKT, TRunResult, TRelations>>(primary: Q, replicas: [Q, ...Q[]], getReplica?: (replicas: Q[]) => Q) => SQLiteEffectWithReplicas<Q>;
+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 {};