@erfanium/drizzle-orm 1.0.0 → 1.0.1

package/bun-sqlite/driver.d.cts

@@ -1,49 +1,52 @@
-import { SQLiteBunRunResult } from "./session.cjs";
-import { entityKind } from "../entity.cjs";
-import { AnyRelations, EmptyRelations } from "../relations.cjs";
-import { DrizzleSQLiteConfig } from "../sqlite-core/utils.cjs";
-import { SQLiteAsyncDatabase } from "../sqlite-core/async/db.cjs";
-import { Database } from "bun:sqlite";
-
-//#region src/bun-sqlite/driver.d.ts
-declare class SQLiteBunDatabase<TRelations extends AnyRelations = EmptyRelations> extends SQLiteAsyncDatabase<'sync', SQLiteBunRunResult, TRelations> {
-  static readonly [entityKind]: string;
+import { Database } from 'bun:sqlite';
+import { entityKind } from '../entity.cjs';
+import type { AnyRelations, EmptyRelations } from '../relations.cjs';
+import { SQLiteAsyncDatabase } from '../sqlite-core/async/db.cjs';
+import type { DrizzleSQLiteConfig } from '../sqlite-core/utils.cjs';
+import { type SQLiteBunRunResult } from './session.cjs';
+export declare class SQLiteBunDatabase<TRelations extends AnyRelations = EmptyRelations> extends SQLiteAsyncDatabase<'sync', SQLiteBunRunResult, TRelations> {
+    static readonly [entityKind]: string;
 }
 type DrizzleSqliteBunDatabaseOptions = {
-  /**
-   * Open the database as read-only (no write operations, no create).
-   *
-   * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-   */
-  readonly?: boolean;
-  /**
-   * Allow creating a new database
-   *
-   * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-   */
-  create?: boolean;
-  /**
-   * Open the database as read-write
-   *
-   * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-   */
-  readwrite?: boolean;
+    /**
+     * Open the database as read-only (no write operations, no create).
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+     */
+    readonly?: boolean;
+    /**
+     * Allow creating a new database
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+     */
+    create?: boolean;
+    /**
+     * Open the database as read-write
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+     */
+    readwrite?: boolean;
 };
-type DrizzleBunSqliteDatabaseConfig = ({
-  source?: string;
+export type DrizzleBunSqliteDatabaseConfig = ({
+    source?: string;
 } & DrizzleSqliteBunDatabaseOptions) | string | undefined;
-declare function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(...params: [] | [string] | [string, DrizzleSQLiteConfig<TRelations>] | [(DrizzleSQLiteConfig<TRelations> & ({
-  connection?: DrizzleBunSqliteDatabaseConfig;
-} | {
-  client: TClient;
-}))]): SQLiteBunDatabase<TRelations> & {
-  $client: TClient;
+export declare function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(...params: [] | [
+    string
+] | [
+    string,
+    DrizzleSQLiteConfig<TRelations>
+] | [
+    (DrizzleSQLiteConfig<TRelations> & ({
+        connection?: DrizzleBunSqliteDatabaseConfig;
+    } | {
+        client: TClient;
+    }))
+]): SQLiteBunDatabase<TRelations> & {
+    $client: TClient;
 };
-declare namespace drizzle {
-  function mock<TRelations extends AnyRelations = EmptyRelations>(config?: DrizzleSQLiteConfig<TRelations>): SQLiteBunDatabase<TRelations> & {
-    $client: '$client is not available on drizzle.mock()';
-  };
+export declare namespace drizzle {
+    function mock<TRelations extends AnyRelations = EmptyRelations>(config?: DrizzleSQLiteConfig<TRelations>): SQLiteBunDatabase<TRelations> & {
+        $client: '$client is not available on drizzle.mock()';
+    };
 }
-//#endregion
-export { DrizzleBunSqliteDatabaseConfig, SQLiteBunDatabase, drizzle };
-//# sourceMappingURL=driver.d.cts.map
+export {};

package/bun-sqlite/driver.d.ts

@@ -1,49 +1,52 @@
-import { SQLiteBunRunResult } from "./session.js";
-import { entityKind } from "../entity.js";
-import { AnyRelations, EmptyRelations } from "../relations.js";
-import { SQLiteAsyncDatabase } from "../sqlite-core/async/db.js";
-import { Database } from "bun:sqlite";
-import { DrizzleSQLiteConfig } from "../sqlite-core/utils.js";
-
-//#region src/bun-sqlite/driver.d.ts
-declare class SQLiteBunDatabase<TRelations extends AnyRelations = EmptyRelations> extends SQLiteAsyncDatabase<'sync', SQLiteBunRunResult, TRelations> {
-  static readonly [entityKind]: string;
+import { Database } from 'bun:sqlite';
+import { entityKind } from '../entity.js';
+import type { AnyRelations, EmptyRelations } from '../relations.js';
+import { SQLiteAsyncDatabase } from '../sqlite-core/async/db.js';
+import type { DrizzleSQLiteConfig } from '../sqlite-core/utils.js';
+import { type SQLiteBunRunResult } from './session.js';
+export declare class SQLiteBunDatabase<TRelations extends AnyRelations = EmptyRelations> extends SQLiteAsyncDatabase<'sync', SQLiteBunRunResult, TRelations> {
+    static readonly [entityKind]: string;
 }
 type DrizzleSqliteBunDatabaseOptions = {
-  /**
-   * Open the database as read-only (no write operations, no create).
-   *
-   * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
-   */
-  readonly?: boolean;
-  /**
-   * Allow creating a new database
-   *
-   * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
-   */
-  create?: boolean;
-  /**
-   * Open the database as read-write
-   *
-   * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
-   */
-  readwrite?: boolean;
+    /**
+     * Open the database as read-only (no write operations, no create).
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+     */
+    readonly?: boolean;
+    /**
+     * Allow creating a new database
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+     */
+    create?: boolean;
+    /**
+     * Open the database as read-write
+     *
+     * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+     */
+    readwrite?: boolean;
 };
-type DrizzleBunSqliteDatabaseConfig = ({
-  source?: string;
+export type DrizzleBunSqliteDatabaseConfig = ({
+    source?: string;
 } & DrizzleSqliteBunDatabaseOptions) | string | undefined;
-declare function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(...params: [] | [string] | [string, DrizzleSQLiteConfig<TRelations>] | [(DrizzleSQLiteConfig<TRelations> & ({
-  connection?: DrizzleBunSqliteDatabaseConfig;
-} | {
-  client: TClient;
-}))]): SQLiteBunDatabase<TRelations> & {
-  $client: TClient;
+export declare function drizzle<TRelations extends AnyRelations = EmptyRelations, TClient extends Database = Database>(...params: [] | [
+    string
+] | [
+    string,
+    DrizzleSQLiteConfig<TRelations>
+] | [
+    (DrizzleSQLiteConfig<TRelations> & ({
+        connection?: DrizzleBunSqliteDatabaseConfig;
+    } | {
+        client: TClient;
+    }))
+]): SQLiteBunDatabase<TRelations> & {
+    $client: TClient;
 };
-declare namespace drizzle {
-  function mock<TRelations extends AnyRelations = EmptyRelations>(config?: DrizzleSQLiteConfig<TRelations>): SQLiteBunDatabase<TRelations> & {
-    $client: '$client is not available on drizzle.mock()';
-  };
+export declare namespace drizzle {
+    function mock<TRelations extends AnyRelations = EmptyRelations>(config?: DrizzleSQLiteConfig<TRelations>): SQLiteBunDatabase<TRelations> & {
+        $client: '$client is not available on drizzle.mock()';
+    };
 }
-//#endregion
-export { DrizzleBunSqliteDatabaseConfig, SQLiteBunDatabase, drizzle };
-//# sourceMappingURL=driver.d.ts.map
+export {};

package/bun-sqlite/index.d.cts

@@ -1,3 +1,2 @@
-import { SQLiteBunRunResult, SQLiteBunSession, SQLiteBunSessionOptions, SQLiteBunTransaction } from "./session.cjs";
-import { DrizzleBunSqliteDatabaseConfig, SQLiteBunDatabase, drizzle } from "./driver.cjs";
-export { DrizzleBunSqliteDatabaseConfig, SQLiteBunDatabase, SQLiteBunRunResult, SQLiteBunSession, SQLiteBunSessionOptions, SQLiteBunTransaction, drizzle };
+export * from './driver.cjs';
+export * from './session.cjs';

package/bun-sqlite/index.d.ts

@@ -1,3 +1,2 @@
-import { SQLiteBunRunResult, SQLiteBunSession, SQLiteBunSessionOptions, SQLiteBunTransaction } from "./session.js";
-import { DrizzleBunSqliteDatabaseConfig, SQLiteBunDatabase, drizzle } from "./driver.js";
-export { DrizzleBunSqliteDatabaseConfig, SQLiteBunDatabase, SQLiteBunRunResult, SQLiteBunSession, SQLiteBunSessionOptions, SQLiteBunTransaction, drizzle };
+export * from './driver.js';
+export * from './session.js';

package/bun-sqlite/migrator.d.cts

@@ -1,10 +1,5 @@
-import { SQLiteBunDatabase } from "./driver.cjs";
-import { MigrationConfig, MigrationFromJournalConfig, MigrationsJournal, MigratorInitFailResponse } from "../migrator.cjs";
-import { AnyRelations, EmptyRelations } from "../relations.cjs";
-
-//#region src/bun-sqlite/migrator.d.ts
-declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationConfig): void | MigratorInitFailResponse;
-declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationFromJournalConfig | MigrationsJournal): void;
-//#endregion
-export { migrate };
-//# sourceMappingURL=migrator.d.cts.map
+import type { MigrationConfig, MigrationFromJournalConfig, MigrationsJournal, MigratorInitFailResponse } from '../migrator.cjs';
+import type { AnyRelations, EmptyRelations } from '../relations.cjs';
+import type { SQLiteBunDatabase } from './driver.cjs';
+export declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationConfig): void | MigratorInitFailResponse;
+export declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationFromJournalConfig | MigrationsJournal): void;

package/bun-sqlite/migrator.d.ts

@@ -1,10 +1,5 @@
-import { SQLiteBunDatabase } from "./driver.js";
-import { MigrationConfig, MigrationFromJournalConfig, MigrationsJournal, MigratorInitFailResponse } from "../migrator.js";
-import { AnyRelations, EmptyRelations } from "../relations.js";
-
-//#region src/bun-sqlite/migrator.d.ts
-declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationConfig): void | MigratorInitFailResponse;
-declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationFromJournalConfig | MigrationsJournal): void;
-//#endregion
-export { migrate };
-//# sourceMappingURL=migrator.d.ts.map
+import type { MigrationConfig, MigrationFromJournalConfig, MigrationsJournal, MigratorInitFailResponse } from '../migrator.js';
+import type { AnyRelations, EmptyRelations } from '../relations.js';
+import type { SQLiteBunDatabase } from './driver.js';
+export declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationConfig): void | MigratorInitFailResponse;
+export declare function migrate<TRelations extends AnyRelations = EmptyRelations>(db: SQLiteBunDatabase<TRelations>, config: MigrationFromJournalConfig | MigrationsJournal): void;

package/bun-sqlite/session.cjs

@@ -3,8 +3,8 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 let __entity_ts = require("../entity.cjs");
 let __sql_sql_ts = require("../sql/sql.cjs");
 let __logger_ts = require("../logger.cjs");
-let __errors_ts = require("../errors.cjs");
 let __sqlite_core_async_session_ts = require("../sqlite-core/async/session.cjs");
+let __errors_ts = require("../errors.cjs");
 
 //#region src/bun-sqlite/session.ts
 var SQLiteBunSession = class extends __sqlite_core_async_session_ts.SQLiteAsyncSession {

package/bun-sqlite/session.d.cts

@@ -1,40 +1,36 @@
-import { entityKind } from "../entity.cjs";
-import { Query } from "../sql/sql.cjs";
-import { DrizzleTypeError } from "../utils.cjs";
-import { AnyRelations } from "../relations.cjs";
-import { Logger } from "../logger.cjs";
-import { SQLiteDialect } from "../sqlite-core/dialect.cjs";
-import { SQLiteExecuteMethod, SQLiteTransactionConfig } from "../sqlite-core/session.cjs";
-import { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession, SQLiteAsyncTransaction } from "../sqlite-core/async/session.cjs";
-import { Changes, Database } from "bun:sqlite";
-
-//#region src/bun-sqlite/session.d.ts
-interface SQLiteBunSessionOptions {
-  logger?: Logger;
-  cache?: Cache;
+import type { Changes, Database } from 'bun:sqlite';
+import { entityKind } from '../entity.cjs';
+import type { Logger } from '../logger.cjs';
+import type { AnyRelations } from '../relations.cjs';
+import { type Query } from '../sql/sql.cjs';
+import { SQLiteAsyncPreparedQuery, type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase, SQLiteAsyncSession, SQLiteAsyncTransaction } from '../sqlite-core/async/session.cjs';
+import type { SQLiteDialect } from '../sqlite-core/dialect.cjs';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '../sqlite-core/session.cjs';
+import type { DrizzleTypeError } from '../utils.cjs';
+export interface SQLiteBunSessionOptions {
+    logger?: Logger;
+    cache?: Cache;
 }
-type SQLiteBunRunResult = Changes;
-type PreparedQueryConfig$1 = Omit<SQLiteAsyncPreparedQueryConfig, 'statement' | 'run'>;
-declare class SQLiteBunSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', SQLiteBunRunResult, TRelations> {
-  private client;
-  private relations;
-  private options;
-  static readonly [entityKind]: string;
-  private logger;
-  constructor(client: Database, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteBunSessionOptions);
-  exec(query: string): void;
-  prepareQuery<T extends Omit<PreparedQueryConfig$1, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  }): SQLiteAsyncPreparedQuery<T & {
-    run: SQLiteBunRunResult;
-  }>;
-  transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T, config?: SQLiteTransactionConfig): T;
+export type SQLiteBunRunResult = Changes;
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+export declare class SQLiteBunSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', SQLiteBunRunResult, TRelations> {
+    private client;
+    private relations;
+    private options;
+    static readonly [entityKind]: string;
+    private logger;
+    constructor(client: Database, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteBunSessionOptions);
+    exec(query: string): void;
+    prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    }): SQLiteAsyncPreparedQuery<T & {
+        run: SQLiteBunRunResult;
+    }>;
+    transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T, config?: SQLiteTransactionConfig): T;
 }
-declare class SQLiteBunTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', SQLiteBunRunResult, TRelations> {
-  static readonly [entityKind]: string;
-  transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
+export declare class SQLiteBunTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', SQLiteBunRunResult, TRelations> {
+    static readonly [entityKind]: string;
+    transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
 }
-//#endregion
-export { SQLiteBunRunResult, SQLiteBunSession, SQLiteBunSessionOptions, SQLiteBunTransaction };
-//# sourceMappingURL=session.d.cts.map
+export {};

package/bun-sqlite/session.d.ts

@@ -1,40 +1,36 @@
-import { entityKind } from "../entity.js";
-import { DrizzleTypeError } from "../utils.js";
-import { Query } from "../sql/sql.js";
-import { Logger } from "../logger.js";
-import { AnyRelations } from "../relations.js";
-import { SQLiteDialect } from "../sqlite-core/dialect.js";
-import { SQLiteAsyncPreparedQuery, SQLiteAsyncPreparedQueryConfig, SQLiteAsyncSession, SQLiteAsyncTransaction } from "../sqlite-core/async/session.js";
-import { SQLiteExecuteMethod, SQLiteTransactionConfig } from "../sqlite-core/session.js";
-import { Changes, Database } from "bun:sqlite";
-
-//#region src/bun-sqlite/session.d.ts
-interface SQLiteBunSessionOptions {
-  logger?: Logger;
-  cache?: Cache;
+import type { Changes, Database } from 'bun:sqlite';
+import { entityKind } from '../entity.js';
+import type { Logger } from '../logger.js';
+import type { AnyRelations } from '../relations.js';
+import { type Query } from '../sql/sql.js';
+import { SQLiteAsyncPreparedQuery, type SQLiteAsyncPreparedQueryConfig as PreparedQueryConfigBase, SQLiteAsyncSession, SQLiteAsyncTransaction } from '../sqlite-core/async/session.js';
+import type { SQLiteDialect } from '../sqlite-core/dialect.js';
+import type { SQLiteExecuteMethod, SQLiteTransactionConfig } from '../sqlite-core/session.js';
+import type { DrizzleTypeError } from '../utils.js';
+export interface SQLiteBunSessionOptions {
+    logger?: Logger;
+    cache?: Cache;
 }
-type SQLiteBunRunResult = Changes;
-type PreparedQueryConfig$1 = Omit<SQLiteAsyncPreparedQueryConfig, 'statement' | 'run'>;
-declare class SQLiteBunSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', SQLiteBunRunResult, TRelations> {
-  private client;
-  private relations;
-  private options;
-  static readonly [entityKind]: string;
-  private logger;
-  constructor(client: Database, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteBunSessionOptions);
-  exec(query: string): void;
-  prepareQuery<T extends Omit<PreparedQueryConfig$1, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
-    type: 'select' | 'update' | 'delete' | 'insert';
-    tables: string[];
-  }): SQLiteAsyncPreparedQuery<T & {
-    run: SQLiteBunRunResult;
-  }>;
-  transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T, config?: SQLiteTransactionConfig): T;
+export type SQLiteBunRunResult = Changes;
+type PreparedQueryConfig = Omit<PreparedQueryConfigBase, 'statement' | 'run'>;
+export declare class SQLiteBunSession<TRelations extends AnyRelations> extends SQLiteAsyncSession<'sync', SQLiteBunRunResult, TRelations> {
+    private client;
+    private relations;
+    private options;
+    static readonly [entityKind]: string;
+    private logger;
+    constructor(client: Database, dialect: SQLiteDialect, relations: TRelations, options?: SQLiteBunSessionOptions);
+    exec(query: string): void;
+    prepareQuery<T extends Omit<PreparedQueryConfig, 'run'>>(query: Query, mode: 'arrays' | 'objects' | 'raw', _prepare: boolean, executeMethod?: SQLiteExecuteMethod, mapper?: (rows: any[]) => any, queryMetadata?: {
+        type: 'select' | 'update' | 'delete' | 'insert';
+        tables: string[];
+    }): SQLiteAsyncPreparedQuery<T & {
+        run: SQLiteBunRunResult;
+    }>;
+    transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T, config?: SQLiteTransactionConfig): T;
 }
-declare class SQLiteBunTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', SQLiteBunRunResult, TRelations> {
-  static readonly [entityKind]: string;
-  transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
+export declare class SQLiteBunTransaction<TRelations extends AnyRelations> extends SQLiteAsyncTransaction<'sync', SQLiteBunRunResult, TRelations> {
+    static readonly [entityKind]: string;
+    transaction<T>(transaction: (tx: SQLiteBunTransaction<TRelations>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
 }
-//#endregion
-export { SQLiteBunRunResult, SQLiteBunSession, SQLiteBunSessionOptions, SQLiteBunTransaction };
-//# sourceMappingURL=session.d.ts.map
+export {};

package/bun-sqlite/session.js

@@ -1,8 +1,8 @@
 import { entityKind } from "../entity.js";
 import { sql } from "../sql/sql.js";
 import { NoopLogger } from "../logger.js";
-import { DrizzleQueryError } from "../errors.js";
 import { SQLiteAsyncPreparedQuery, SQLiteAsyncSession, SQLiteAsyncTransaction } from "../sqlite-core/async/session.js";
+import { DrizzleQueryError } from "../errors.js";
 
 //#region src/bun-sqlite/session.ts
 var SQLiteBunSession = class extends SQLiteAsyncSession {

package/cache/core/cache-effect.d.cts

@@ -1,23 +1,20 @@
-import { CacheConfig } from "./types.cjs";
-import { Cache, MutationOption } from "./cache.cjs";
-import { entityKind } from "../../entity.cjs";
-import * as effect_Cause0 from "effect/Cause";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Schema$1 from "effect/Schema";
-
-//#region src/cache/core/cache-effect.d.ts
-interface EffectCacheShape {
-  readonly strategy: () => 'explicit' | 'all';
-  readonly get: (key: string, tables: string[], isTag: boolean, isAutoInvalidate?: boolean) => Effect.Effect<any[] | undefined, EffectCacheError, never>;
-  readonly put: (hashedQuery: string, response: any, tables: string[], isTag: boolean, config?: CacheConfig) => Effect.Effect<void, EffectCacheError, never>;
-  readonly onMutate: (params: MutationOption) => Effect.Effect<void, EffectCacheError, never>;
-  /** Container for async cache if made by wrapping one */
-  readonly cache?: Cache;
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
+import { entityKind } from '../../entity.cjs';
+import { type Cache as DrizzleCache, type MutationOption } from './cache.cjs';
+import type { CacheConfig } from './types.cjs';
+export interface EffectCacheShape {
+    readonly strategy: () => 'explicit' | 'all';
+    readonly get: (key: string, tables: string[], isTag: boolean, isAutoInvalidate?: boolean) => Effect.Effect<any[] | undefined, EffectCacheError, never>;
+    readonly put: (hashedQuery: string, response: any, tables: string[], isTag: boolean, config?: CacheConfig) => Effect.Effect<void, EffectCacheError, never>;
+    readonly onMutate: (params: MutationOption) => Effect.Effect<void, EffectCacheError, never>;
+    /** Container for async cache if made by wrapping one */
+    readonly cache?: DrizzleCache;
 }
 declare const EffectCache_base: Context.ServiceClass<EffectCache, "drizzle-orm/EffectCache", EffectCacheShape> & {
-  readonly make: Effect.Effect<EffectCacheShape, never, never>;
+    readonly make: Effect.Effect<EffectCacheShape, never, never>;
 };
 /**
  * Effect service for caching query results in Drizzle ORM.
@@ -39,54 +36,52 @@ declare const EffectCache_base: Context.ServiceClass<EffectCache, "drizzle-orm/E
  * );
  * ```
  */
-declare class EffectCache extends EffectCache_base {
-  static readonly [entityKind]: string;
-  /**
-   * The default layer providing a no-op cache.
-   */
-  static readonly Default: Layer.Layer<EffectCache, never, never>;
-  /**
-   * Creates an EffectCacheShape from a standard Drizzle cache.
-   *
-   * @param cache - A Drizzle cache instance implementing the `Cache` interface.
-   * @returns A new EffectCacheShape that delegates to the provided Drizzle cache.
-   *
-   * @example
-   * ```ts
-   * const drizzleCache = new MyCustomCache();
-   * const effectCache = EffectCache.fromDrizzle(drizzleCache);
-   * ```
-   */
-  static fromDrizzle(cache: Cache): EffectCacheShape;
-  /**
-   * Creates a Layer that provides an EffectCache from a standard Drizzle cache.
-   *
-   * @param cache - A Drizzle cache instance implementing the `Cache` interface.
-   * @returns A Layer that provides the EffectCache service.
-   *
-   * @example
-   * ```ts
-   * const drizzleCache = new MyCustomCache();
-   * const db = yield* PgDrizzle.make({ relations }).pipe(
-   *   Effect.provide(EffectCache.layerFromDrizzle(drizzleCache)),
-   *   Effect.provide(PgDrizzle.DefaultServices),
-   * );
-   * ```
-   */
-  static layerFromDrizzle(cache: Cache): Layer.Layer<EffectCache, never, never>;
+export declare class EffectCache extends EffectCache_base {
+    static readonly [entityKind]: string;
+    /**
+     * The default layer providing a no-op cache.
+     */
+    static readonly Default: Layer.Layer<EffectCache, never, never>;
+    /**
+     * Creates an EffectCacheShape from a standard Drizzle cache.
+     *
+     * @param cache - A Drizzle cache instance implementing the `Cache` interface.
+     * @returns A new EffectCacheShape that delegates to the provided Drizzle cache.
+     *
+     * @example
+     * ```ts
+     * const drizzleCache = new MyCustomCache();
+     * const effectCache = EffectCache.fromDrizzle(drizzleCache);
+     * ```
+     */
+    static fromDrizzle(cache: DrizzleCache): EffectCacheShape;
+    /**
+     * Creates a Layer that provides an EffectCache from a standard Drizzle cache.
+     *
+     * @param cache - A Drizzle cache instance implementing the `Cache` interface.
+     * @returns A Layer that provides the EffectCache service.
+     *
+     * @example
+     * ```ts
+     * const drizzleCache = new MyCustomCache();
+     * const db = yield* PgDrizzle.make({ relations }).pipe(
+     *   Effect.provide(EffectCache.layerFromDrizzle(drizzleCache)),
+     *   Effect.provide(PgDrizzle.DefaultServices),
+     * );
+     * ```
+     */
+    static layerFromDrizzle(cache: DrizzleCache): Layer.Layer<EffectCache, never, never>;
 }
-declare const EffectCacheError_base: Schema$1.Class<EffectCacheError, Schema$1.TaggedStruct<"EffectCacheError", {
-  readonly cause: Schema$1.Unknown;
-}>, effect_Cause0.YieldableError>;
+declare const EffectCacheError_base: Schema.Class<EffectCacheError, Schema.TaggedStruct<"EffectCacheError", {
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
 /**
  * Error type for cache operation failures.
  *
  * This error is thrown when any cache operation (get, put, onMutate) fails.
  * The original error is available in the `cause` property.
  */
-declare class EffectCacheError extends EffectCacheError_base {
-  static readonly [entityKind]: string;
+export declare class EffectCacheError extends EffectCacheError_base {
+    static readonly [entityKind]: string;
 }
-//#endregion
-export { EffectCache, EffectCacheError, EffectCacheShape };
-//# sourceMappingURL=cache-effect.d.cts.map
+export {};