---
title: Drizzle API
description: Generated public TypeScript reference for @relkit/drizzle.
search:
  exclude: true
sidebar:
  icon: braces
---

{/* Generated by apps/docs/scripts/generate.ts. Do not edit. */}

## Common APIs

- [defineDrizzleService](/docs/api/drizzle#definedrizzleservice)
- [defineModel](/docs/api/drizzle#definemodel)
- [activateDrizzleService](/docs/api/drizzle#activatedrizzleservice)

For configuration and examples, read [Database](/docs/modules/database), [local docker](/docs/modules/database/local-docker), [drizzle](/docs/modules/database/drizzle).

For a complete workflow, follow [register users in a transaction](/guides/database/register-users-in-a-transaction), [email password sign in](/guides/auth/email-password-sign-in).

## Public imports

- `@relkit/drizzle` — 23 exports
- `@relkit/drizzle/sqlite` — 24 exports
- `@relkit/drizzle/pg` — 24 exports
- `@relkit/drizzle/mysql` — 24 exports

## All exported APIs

Names link to their complete contracts. Re-exports share their original contract; legacy exports keep their separate identity. Examples link to the API's inline sample, a maintained repository usage, or the shared module walkthrough.

| API                                                                               | Kind  | Import from                                                                                | Example                                                                                                                           |
| --------------------------------------------------------------------------------- | ----- | ------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| [activateDrizzleService](/docs/api/drizzle#activatedrizzleservice)                | Value | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Source example](https://github.com/rel-kit/relkit/blob/main/packages/better-auth/tests/auth/acquisition.test.ts#L55)             |
| [ApplicationEnv](/docs/api/drizzle#applicationenv-type-alias)                     | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [BaseOperations](/docs/api/drizzle#baseoperations-interface)                      | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [DatabaseContext](/docs/api/drizzle#databasecontext-type-alias)                   | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Source example](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/tests/effect/review-regressions.test.ts#L98)        |
| [defineDrizzleService](/docs/api/drizzle#definedrizzleservice-1)                  | Value | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [API example](/docs/api/drizzle#definedrizzleservice-1)                                                                           |
| [defineModel](/docs/api/drizzle#definemodel-1)                                    | Value | `@relkit/drizzle`                                                                          | [API example](/docs/api/drizzle#definemodel-1)                                                                                    |
| [defineModel](/docs/api/drizzle#definemodel-4)                                    | Value | `@relkit/drizzle/sqlite`                                                                   | [Source example](https://github.com/rel-kit/relkit/blob/main/examples/data-model/src/services/database/models/users.model.ts#L6)  |
| [defineModel](/docs/api/drizzle#definemodel-3)                                    | Value | `@relkit/drizzle/pg`                                                                       | [Module example](/docs/modules/database)                                                                                          |
| [defineModel](/docs/api/drizzle#definemodel-2)                                    | Value | `@relkit/drizzle/mysql`                                                                    | [Module example](/docs/modules/database)                                                                                          |
| [DeleteArgs](/docs/api/drizzle#deleteargs-interface)                              | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [DialectDatabase](/docs/api/drizzle#dialectdatabase-type-alias-2)                 | Type  | `@relkit/drizzle/sqlite`                                                                   | [Module example](/docs/modules/database)                                                                                          |
| [DialectDatabase](/docs/api/drizzle#dialectdatabase-type-alias-1)                 | Type  | `@relkit/drizzle/pg`                                                                       | [Module example](/docs/modules/database)                                                                                          |
| [DialectDatabase](/docs/api/drizzle#dialectdatabase-type-alias)                   | Type  | `@relkit/drizzle/mysql`                                                                    | [Module example](/docs/modules/database)                                                                                          |
| [DrizzleActivationOptions](/docs/api/drizzle#drizzleactivationoptions-interface)  | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [DrizzleCapability](/docs/api/drizzle#drizzlecapability-interface)                | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [DrizzleOverrides](/docs/api/drizzle#drizzleoverrides-type-alias)                 | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [DrizzleServiceDescriptor](/docs/api/drizzle#drizzleservicedescriptor-type-alias) | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [FindManyArgs](/docs/api/drizzle#findmanyargs-interface)                          | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [FindOneArgs](/docs/api/drizzle#findoneargs-interface)                            | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [InsertArgs](/docs/api/drizzle#insertargs-interface)                              | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [ModelDescriptor](/docs/api/drizzle#modeldescriptor-interface)                    | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [ModelExtensionContext](/docs/api/drizzle#modelextensioncontext-interface)        | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [Row](/docs/api/drizzle#row-type-alias)                                           | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [TableOverrides](/docs/api/drizzle#tableoverrides-type-alias)                     | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [TableZodSchemas](/docs/api/drizzle#tablezodschemas-interface)                    | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [Update](/docs/api/drizzle#update-type-alias)                                     | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [UpdateArgs](/docs/api/drizzle#updateargs-interface)                              | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Source example](https://github.com/rel-kit/relkit/blob/main/examples/data-model/src/services/database/models/users.model.ts#L14) |
| [UpsertArgs](/docs/api/drizzle#upsertargs-interface)                              | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |
| [Where](/docs/api/drizzle#where-type-alias)                                       | Type  | `@relkit/drizzle`, `@relkit/drizzle/sqlite`, `@relkit/drizzle/pg`, `@relkit/drizzle/mysql` | [Module example](/docs/modules/database)                                                                                          |

## `activate.ts`

Validates the selected ORM before loading runtime activation or calling the native factory.

### activateDrizzleService

Acquires a database using the existing owner after selected dependency validation.

**Signature**

```ts
declare const activateDrizzleService: <
  Service extends DrizzleServiceDescriptor<any, any, any, any>,
>(
  service: Service,
  env: Readonly<Record<string, unknown>>,
  options?: DrizzleActivationOptions,
) => Promise<DrizzleActivation<Service>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/activate.ts#L12)

## `activation.ts`

### activateDrizzleService

Activates a service once per descriptor object and returns its client, context, and close hook.
Repeated calls share the first activation; close does not evict the cached activation.
Isolated acquisition bypasses that cache and transfers close ownership to the caller.

**Example**

```ts
import { activateDrizzleService, defineDrizzleService } from "@relkit/drizzle";
import { integer, sqliteTable } from "drizzle-orm/sqlite-core";

if (typeof Bun !== "undefined") {
  const { Database } = await import("bun:sqlite");
  const { drizzle } = await import("drizzle-orm/bun-sqlite");
  const users = sqliteTable("users", { id: integer().primaryKey() });
  const service = defineDrizzleService({
    schema: { users },
    client: () => drizzle({ client: new Database(":memory:") }),
    dispose: (database) => database.$client.close(),
  });
  const active = await activateDrizzleService(service, {});
  try {
    console.assert(active.context.users !== undefined);
  } finally {
    await active.close();
  }
}
```

**Signature**

```ts
declare const activateDrizzleService: <
  Service extends DrizzleServiceDescriptor<any, any, any, any>,
>(
  service: Service,
  env: Readonly<Record<string, unknown>>,
  options?: DrizzleActivationOptions,
) => Promise<DrizzleActivation<Service>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/activation.ts#L58)

Since v0.1.0

### DrizzleActivation

**Signature**

```ts
declare const DrizzleActivation: DrizzleActivation<Service>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/activation.ts#L22)

### DrizzleActivationOptions

**Signature**

```ts
declare const DrizzleActivationOptions: DrizzleActivationOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/activation.ts#L22)

## `activation.types.ts`

### DrizzleActivation (interface)

Frozen public activation; resource ownership ends at close.

**Signature**

```ts
export interface DrizzleActivation<Service extends DrizzleServiceDescriptor<any, any, any, any>> {
  /** Native escape hatch; callers must use admitted APIs to guarantee orderly close. */
  readonly client: Service extends DrizzleServiceDescriptor<any, infer Client, any, any>
    ? Client
    : never;
  readonly context: DatabaseContext<Service>;
  /**
   * Stops admission and releases the owner after admitted native work settles.
   * @returns Shared close Promise; later calls observe the same completion.
   */
  readonly close: () => Promise<void>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/activation.types.ts#L16)

### DrizzleActivationOptions (interface)

Acquisition policy for an application that owns its database lifetime.

**Signature**

```ts
export interface DrizzleActivationOptions {
  /** Bypasses descriptor sharing; the caller must close this activation. */
  readonly isolated?: boolean;
  /** Configured observation services captured by the compatibility owner. */
  readonly instrumentation?: Context.Context<never>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/activation.types.ts#L5)

## `context.ts`

### createDatabaseContext

Constructs models without acquiring another client.

**See**

- `activateDrizzleService` for the checked public owner lifecycle.

**Signature**

```ts
declare const createDatabaseContext: <Service extends DrizzleServiceDescriptor<any, any, any, any>>(
  service: Service,
  runtime: DrizzleServiceRuntime,
  database: unknown,
  run: ContextRunner,
) => DatabaseContext<Service>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/context.ts#L22)

## `context.types.ts`

### ContextRunner (type alias)

Executes work at the existing owner edge; transaction children borrow their parent lease.

**Signature**

```ts
type ContextRunner = <A>(effect: Effect.Effect<A, DrizzleFailure>, operation: string) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/context.types.ts#L11)

## `coordination.ts`

### withDrizzleSqliteWork

Coordinates raw specialized SDK work with portable SQLite operations.

**Signature**

```ts
declare const withDrizzleSqliteWork: <A, E, R>(
  activation: object,
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, E | DrizzleFailure, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/coordination.ts#L17)

## `failure.ts`

### DrizzleFailure (class)

Expected native database, validation or owner-admission failure.

**Signature**

```ts
declare class DrizzleFailure
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/failure.ts#L6)

### nativeCall

Suspends an uncancellable SDK call until actual completion.

**See**

- `runDrizzlePromise` for execution at the owning runtime boundary.

**Signature**

```ts
declare const nativeCall: <A>(
  operation: string,
  run: () => A | PromiseLike<A>,
) => Effect.Effect<A, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/failure.ts#L20)

### runDrizzlePromise

Executes a compatibility edge retaining original native rejection identity.

**Example**

```ts
import { Effect, Layer, ManagedRuntime } from "effect";
import { runDrizzlePromise } from "@relkit/drizzle/internal";
const owner = ManagedRuntime.make(Layer.empty);
try {
  await runDrizzlePromise(owner, Effect.succeed(1));
} finally {
  await owner.dispose();
}
```

**Signature**

```ts
declare const runDrizzlePromise: <A, E, R, ER>(
  runtime: ManagedRuntime.ManagedRuntime<R, ER>,
  effect: Effect.Effect<A, E, R>,
  options?: Effect.RunOptions,
) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/failure.ts#L50)

### squashDrizzleCause

Translates one native failure without erasing mixed cleanup/interruption causes.

**Signature**

```ts
declare const squashDrizzleCause: <E>(cause: Cause.Cause<E>) => unknown;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/failure.ts#L66)

## `index.ts`

Lazy Drizzle declarations and stable Promise model/transaction compatibility APIs.

### ApplicationEnv

**Signature**

```ts
declare const ApplicationEnv: Readonly<Record<string, string>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L10)

### BaseOperations

**Signature**

```ts
declare const BaseOperations: BaseOperations<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L11)

### DatabaseContext

**Signature**

```ts
declare const DatabaseContext: DatabaseContext<Service>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L12)

### DeleteArgs

**Signature**

```ts
declare const DeleteArgs: DeleteArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L13)

### DrizzleActivationOptions

**Signature**

```ts
declare const DrizzleActivationOptions: DrizzleActivationOptions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L6)

### DrizzleCapability

**Signature**

```ts
declare const DrizzleCapability: DrizzleCapability;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L14)

### DrizzleOverrides

**Signature**

```ts
declare const DrizzleOverrides: DrizzleOverrides<Tables>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L15)

### DrizzleServiceDescriptor

**Signature**

```ts
declare const DrizzleServiceDescriptor: DrizzleServiceDescriptor<Id, Client, Schema, Models>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L16)

### FindManyArgs

**Signature**

```ts
declare const FindManyArgs: FindManyArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L17)

### FindOneArgs

**Signature**

```ts
declare const FindOneArgs: FindOneArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L18)

### InsertArgs

**Signature**

```ts
declare const InsertArgs: InsertArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L19)

### ModelDescriptor

**Signature**

```ts
declare const ModelDescriptor: ModelDescriptor<T, Extensions>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L20)

### ModelExtensionContext

**Signature**

```ts
declare const ModelExtensionContext: ModelExtensionContext<T, Database>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L21)

### Row

**Signature**

```ts
declare const Row: {
  [
    K in keyof {
      [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    }
  ]: {
    [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  }[K];
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L22)

### TableOverrides

**Signature**

```ts
declare const TableOverrides: TableOverrides<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L23)

### TableZodSchemas

**Signature**

```ts
declare const TableZodSchemas: TableZodSchemas<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L24)

### Update

**Signature**

```ts
declare const Update: Partial<{
  [
    K in keyof ({
      [
        Key in keyof T["_"]["columns"] & string as RequiredKeyOnly<Key, T["_"]["columns"][Key]>
      ]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    } & {
      [
        Key in keyof T["_"]["columns"] & string as OptionalKeyOnly<
          Key,
          T["_"]["columns"][Key],
          false
        >
      ]?:
        | (T["_"]["columns"][Key]["_"]["notNull"] extends true
            ? T["_"]["columns"][Key]["_"]["data"]
            : T["_"]["columns"][Key]["_"]["data"] | null)
        | undefined;
    })
  ]: ({
    [
      Key in keyof T["_"]["columns"] & string as RequiredKeyOnly<Key, T["_"]["columns"][Key]>
    ]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  } & {
    [
      Key in keyof T["_"]["columns"] & string as OptionalKeyOnly<Key, T["_"]["columns"][Key], false>
    ]?:
      | (T["_"]["columns"][Key]["_"]["notNull"] extends true
          ? T["_"]["columns"][Key]["_"]["data"]
          : T["_"]["columns"][Key]["_"]["data"] | null)
      | undefined;
  })[K];
}>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L25)

### UpdateArgs

**Signature**

```ts
declare const UpdateArgs: UpdateArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L26)

### UpsertArgs

**Signature**

```ts
declare const UpsertArgs: UpsertArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L27)

### Where

**Signature**

```ts
declare const Where: Partial<{
  [
    K in keyof {
      [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    }
  ]: {
    [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  }[K];
}>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L28)

### activateDrizzleService

**Signature**

```ts
declare const activateDrizzleService: <
  Service extends DrizzleServiceDescriptor<any, any, any, any>,
>(
  service: Service,
  env: Readonly<Record<string, unknown>>,
  options?: DrizzleActivationOptions,
) => Promise<DrizzleActivation<Service>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L5)

### defineDrizzleService

**Signature**

```ts
declare const defineDrizzleService: <
  Client,
  const Schema extends Readonly<Record<string, unknown>>,
  const Models extends DrizzleModelMap<TablesOf<Schema>> = {},
>(
  options: DefineDrizzleServiceOptions<Client, Schema, Models>,
) => DrizzleServiceDescriptor<string, Client, Schema, Models>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L8)

### defineModel

**Signature**

```ts
declare const defineModel: <
  const T extends Table,
  const Extensions extends ModelExtensionMap<T>,
>(options: {
  readonly table: T;
  readonly extend: NonEmptyExtensions<Extensions>;
}) => ModelDescriptor<T, Extensions>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/index.ts#L7)

## `internal.ts`

Server-only runtime ownership, typed failures and borrowed-work composition.

### DrizzleActivation

**Signature**

```ts
declare const DrizzleActivation: DrizzleActivation<Service>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L6)

### DrizzleFailure

**Signature**

```ts
declare const DrizzleFailure: typeof DrizzleFailure;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L9)

### DrizzleOwner

**Signature**

```ts
declare const DrizzleOwner: typeof DrizzleOwner;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L11)

### DrizzleOwnerInterface

**Signature**

```ts
declare const DrizzleOwnerInterface: DrizzleOwnerInterface;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L18)

### DrizzleServiceDescriptor

**Signature**

```ts
declare const DrizzleServiceDescriptor: DrizzleServiceDescriptor<Id, Client, Schema, Models>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L8)

### activateDrizzleService

**Signature**

```ts
declare const activateDrizzleService: <
  Service extends DrizzleServiceDescriptor<any, any, any, any>,
>(
  service: Service,
  env: Readonly<Record<string, unknown>>,
  options?: DrizzleActivationOptions,
) => Promise<DrizzleActivation<Service>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L5)

### drizzleInstrumentationOf

**Signature**

```ts
declare const drizzleInstrumentationOf: (activation: object) => Context<never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L14)

### drizzleOwnerLayer

**Signature**

```ts
declare const drizzleOwnerLayer: (
  declaration: DrizzleServiceRuntime,
  env: Readonly<Record<string, unknown>>,
) => Layer<DrizzleOwner, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L12)

### drizzleRuntimeOf

**Signature**

```ts
declare const drizzleRuntimeOf: (value: object) => DrizzleServiceRuntime;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L7)

### inheritNativeLeases

**Signature**

```ts
declare const inheritNativeLeases: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L21)

### nativeCall

**Signature**

```ts
declare const nativeCall: <A>(
  operation: string,
  run: () => A | PromiseLike<A>,
) => Effect<A, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L9)

### observeSpecializedOperation

**Signature**

```ts
declare const observeSpecializedOperation: <A, E, R>(
  operation: `database.${string}` | `auth.${string}`,
  effect: Effect<A, E, R>,
) => Effect<A, E, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L17)

### operationEffect

**Signature**

```ts
declare const operationEffect: (
  binding: ModelBinding,
  name: string,
  args: unknown,
) => Effect<unknown, DrizzleFailure>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L19)

### redactSpecializedTrace

**Signature**

```ts
declare const redactSpecializedTrace: <A, E, R>(
  effect: Effect<A, E, R>,
) => Effect<A, E, Exclude<R, never>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L22)

### runDrizzlePromise

**Signature**

```ts
declare const runDrizzlePromise: <A, E, R, ER>(
  runtime: ManagedRuntime<R, ER>,
  effect: Effect<A, E, R>,
  options?: RunOptions,
) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L9)

### runDrizzleWorkPromise

**Signature**

```ts
declare const runDrizzleWorkPromise: <A, E>(activation: object, effect: Effect<A, E>) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L15)

### runSpecializedTrace

**Signature**

```ts
declare const runSpecializedTrace: <A>(operation: string, run: () => Promise<A>) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L17)

### squashDrizzleCause

**Signature**

```ts
declare const squashDrizzleCause: <E>(cause: Cause<E>) => unknown;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L9)

### withDrizzleSqliteWork

**Signature**

```ts
declare const withDrizzleSqliteWork: <A, E, R>(
  activation: object,
  effect: Effect<A, E, R>,
) => Effect<A, E | DrizzleFailure, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L20)

### withDrizzleWork

**Signature**

```ts
declare const withDrizzleWork: <A, E, R>(
  activation: object,
  effect: Effect<A, E, R>,
) => Effect<A, E | DrizzleFailure, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/internal.ts#L13)

## `metadata.ts`

Extracts native table and column metadata for portable model validation and activation.
Dialect table utilities avoid importing unrelated native driver database declarations.

### dialectFor

Resolves a supported table dialect using Drizzle's entity guards.

**Throws**

TypeError for unsupported entities.

**Signature**

```ts
declare const dialectFor: (table: Table) => "pg" | "mysql" | "sqlite";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/metadata.ts#L54)

### extractTables

Filters relations and other schema values from supported tables.

**Throws**

TypeError when no supported table exists.

**Signature**

```ts
declare const extractTables: (schema: Readonly<Record<string, unknown>>) => TableMap;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/metadata.ts#L40)

### inspectTables

Discovers one consistent dialect and unique table selectors.

**Throws**

TypeError for absent tables or mixed/unsupported dialects.

**Signature**

```ts
declare const inspectTables: (tables: TableMap) => {
  readonly dialect: "pg" | "mysql" | "sqlite";
  readonly metadata: Readonly<Record<string, TableMetadata>>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/metadata.ts#L18)

## `model.ts`

Declares frozen model extensions and binds their native calls to the owning database admission scope.
Dialect leaves provide precise database methods while shared descriptors preserve authored operation inference.

### defineModel

Adds named table methods with an injected table and transaction-aware Drizzle client.
Use service overrides, not extensions, to replace the six reserved CRUD operations.
Select a dialect entrypoint when an extension uses the injected native database.

**Throws**

TypeError for missing, non-callable or reserved extensions.

**Example**

```ts
import { defineModel } from "@relkit/drizzle/sqlite";
import { integer, sqliteTable } from "drizzle-orm/sqlite-core";

const users = sqliteTable("users", { id: integer().primaryKey() });
const model = defineModel({
  table: users,
  extend: { firstTen: ({ table, database }) => database.select().from(table).limit(10) },
});
console.assert(model.extensionNames.includes("firstTen"));
```

**Signature**

```ts
declare const defineModel: <
  const T extends Table,
  const Extensions extends ModelExtensionMap<T>,
>(options: {
  readonly table: T;
  readonly extend: NonEmptyExtensions<Extensions>;
}) => ModelDescriptor<T, Extensions>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.ts#L54)

Since v0.1.0

### RESERVED_OPERATIONS

Reserved base operations; authored extensions may not shadow these names.

**Signature**

```ts
declare const RESERVED_OPERATIONS: readonly [
  "findOne",
  "findMany",
  "insert",
  "update",
  "upsert",
  "delete",
];
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.ts#L20)

### createBoundModel

Binds public Promise methods to the owning Effect workflows.

**Signature**

```ts
declare const createBoundModel: (binding: ModelBinding, model?: ModelDescriptorAny) => object;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.ts#L101)

### modelRuntimeOf

Resolves hidden pure extension metadata.

**Throws**

TypeError for invalid descriptors.

**Signature**

```ts
declare const modelRuntimeOf: (value: ModelDescriptorAny) => ModelRuntime;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.ts#L87)

## `model.types.ts`

Native model injection contracts without an implicit database driver selection.

### DefineModel (type alias)

Native model authoring signature specialized by an explicitly selected dialect entrypoint.

**Signature**

```ts
type DefineModel<Database> = <
  const T extends Table,
  const Extensions extends ModelExtensionMap<T, Database>,
>(options: {
  readonly table: T;
  readonly extend: NonEmptyExtensions<Extensions>;
}) => ModelDescriptor<T, Extensions>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L60)

### ModelDescriptor (interface)

Frozen lazy model descriptor retaining authored extension types.

**Signature**

```ts
export interface ModelDescriptor<
  T extends Table,
  Extensions extends ModelExtensionMap<T> = ModelExtensionMap<T>,
> {
  readonly table: T;
  readonly extensionNames: readonly Extract<keyof Extensions, string>[];
  readonly [MODEL_TYPES]: Extensions;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L47)

### ModelDescriptorAny (type alias)

Internal erased model descriptor used for pure discovery.

**Signature**

```ts
type ModelDescriptorAny = ModelDescriptor<Table, ModelExtensionMap<Table>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L57)

### ModelExtension (type alias)

Authored native extension with inferred caller arguments/results.

**Signature**

```ts
type ModelExtension<T extends Table, Database = never> = (
  context: ModelExtensionContext<T, Database>,
  ...args: any[]
) => unknown;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L20)

### ModelExtensionContext (interface)

Injected table and transaction-bound native database.

**Signature**

```ts
export interface ModelExtensionContext<T extends Table, Database = never> {
  readonly table: T;
  readonly database: Database;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L8)

### ModelExtensionMap (type alias)

Named authored extension functions.

**Signature**

```ts
type ModelExtensionMap<T extends Table, Database = never> = Readonly<
  Record<string, ModelExtension<T, Database>>
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L29)

### NonEmptyExtensions (type alias)

Rejects declarations without any custom methods.

**Signature**

```ts
type NonEmptyExtensions<Extensions extends Readonly<Record<string, unknown>>> =
  keyof Extensions extends never ? never : Extensions;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/model.types.ts#L37)

## `mutations.ts`

### insert

Inserts one row, recovering MySQL rows via a declared unique key.

**Signature**

```ts
declare const insert: (
  binding: ModelBinding,
  data: unknown,
) => Effect.Effect<unknown, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/mutations.ts#L14)

### remove

Deletes one row while preserving dialect return behavior.

**Signature**

```ts
declare const remove: (
  binding: ModelBinding,
  where: Record<string, unknown>,
) => Effect.Effect<{} | null, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/mutations.ts#L77)

### update

Updates one selected row with dialect-aware returning/recovery.

**Signature**

```ts
declare const update: (
  binding: ModelBinding,
  where: Record<string, unknown>,
  data: unknown,
) => Effect.Effect<{} | null, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/mutations.ts#L44)

## `mysql.ts`

mysql native model typing; imports only this selected dialect's upstream declarations.

### "./index.js" (namespace export)

Re-exports all named exports from the "./index.js" module.

**Signature**

```ts
export * from "./index.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/mysql.ts#L5)

### DialectDatabase (type alias)

Native database injected into model extensions for the selected dialect.

**Signature**

```ts
type DialectDatabase = Omit<MySqlAsyncDatabase<any, any>, "query">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/mysql.ts#L8)

### defineModel

Declares lazy native extensions with this dialect's real transaction client type.

**Signature**

```ts
declare const defineModel: DefineModel<DialectDatabase>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/mysql.ts#L11)

## `native-leases.ts`

### NativeLeases

Effect-local owner/physical-client leases, absent for independent callers.

**Signature**

```ts
declare const NativeLeases: Context.Reference<NativeLeaseContext>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L8)

### closeNativeLease

Drains retained descendants, then atomically closes the token at zero.

**Signature**

```ts
declare const closeNativeLease: (lease: NativeLease) => Effect.Effect<void, never, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L96)

### inheritNativeLeases

Carries active parent leases into a new native Promise execution edge.

**Signature**

```ts
declare const inheritNativeLeases: <A, E, R>(
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, E, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L20)

### makeNativeLease

Creates an Effect-owned descendant lease.

**Signature**

```ts
declare const makeNativeLease: (key: object) => Effect.Effect<
  {
    key: object;
    state: Ref.Ref<{ accepting: boolean; closing: boolean; borrowers: number }>;
    drained: Latch.Latch;
  },
  never,
  never
>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L47)

### releaseNativeLease

Releases one retained descendant after safe native settlement.

**Signature**

```ts
declare const releaseNativeLease: (lease: NativeLease) => Effect.Effect<void, never, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L79)

### retainNativeLease

Retains a still-active parent token atomically.

**Signature**

```ts
declare const retainNativeLease: (lease: NativeLease) => Effect.Effect<boolean, never, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L62)

### runWithNativeLeases

Makes native SDK callbacks inherit the currently retained Effect leases.

**Signature**

```ts
declare const runWithNativeLeases: <A>(leases: NativeLeaseContext, run: () => A) => A;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.ts#L38)

## `native-leases.types.ts`

### NativeLease (interface)

Effect-owned ephemeral lease with a drain barrier for retained descendants.

**Signature**

```ts
export interface NativeLease {
  readonly key: object;
  readonly state: Ref.Ref<{
    readonly accepting: boolean;
    readonly closing: boolean;
    readonly borrowers: number;
  }>;
  readonly drained: Latch.Latch;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.types.ts#L4)

### NativeLeaseContext (interface)

Native transport for exact owner and physical client capabilities.

**Signature**

```ts
export interface NativeLeaseContext {
  readonly owner?: NativeLease;
  readonly sqlite?: NativeLease;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/native-leases.types.ts#L15)

## `operation-tracing.ts`

### observeSpecializedOperation

Observes specialized work once through the configured caller sinks.

**Example**

```ts
import { Effect } from "effect";
import { observeSpecializedOperation } from "@relkit/drizzle/internal";
await Effect.runPromise(observeSpecializedOperation("auth.session", Effect.succeed(null)));
```

**Signature**

```ts
declare const observeSpecializedOperation: <A, E, R>(
  operation: `database.${string}` | `auth.${string}`,
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, E, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operation-tracing.ts#L39)

### runSpecializedTrace

Bridges invocation parenting without capturing native rows or auth sessions.

**Signature**

```ts
declare const runSpecializedTrace: <A>(operation: string, run: () => Promise<A>) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operation-tracing.ts#L62)

## `operations.ts`

### operationEffect

Composes overrides and MySQL write/recovery transaction ownership.

**Example**

````ts
Compose a page with an existing owner and table binding
```ts
import { Effect } from "effect";
import type { ManagedRuntime } from "effect";
import { DrizzleFailure, DrizzleOwner, operationEffect, runDrizzlePromise } from "@relkit/drizzle/internal";
function page(owner: ManagedRuntime.ManagedRuntime<DrizzleOwner, DrizzleFailure>, binding: Parameters<typeof operationEffect>[0]) {
  return runDrizzlePromise(owner, Effect.gen(function* () {
    const service = yield* DrizzleOwner;
    return yield* service.work(operationEffect(binding, "findMany", { limit: 10 }));
  }));
}
````

````

**Signature**

```ts
declare const operationEffect: (binding: ModelBinding, name: string, args: unknown) => Effect.Effect<unknown, DrizzleFailure>
````

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.ts#L41)

### runOperation

Runs one lazy CRUD workflow at its compatibility edge.

**Signature**

```ts
declare const runOperation: (
  binding: ModelBinding,
  name: string,
  args: unknown,
) => Promise<unknown>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.ts#L18)

## `operations.types.ts`

### BaseOperations (interface)

Stable public Promise CRUD contract over one table.

**Signature**

```ts
export interface BaseOperations<T extends Table> {
  /**
   * Selects one row by a complete unique key.
   * @param args - Unique selector.
   * @returns Matching row or null, rejecting invalid selectors/native failures.
   */
  findOne(args: FindOneArgs<T>): Promise<Row<T> | null>;

  /**
   * Selects a bounded ordered page.
   * @param args - Optional filters, ordering and pagination.
   * @returns Validated rows in driver order.
   */
  findMany(args?: FindManyArgs<T>): Promise<Row<T>[]>;

  /**
   * Inserts one row without automatic retries.
   * @param args - Insert values.
   * @returns Validated inserted row.
   */
  insert(args: InsertArgs<T>): Promise<Row<T>>;

  /**
   * Updates one selected row without automatic retries.
   * @param args - Unique selector and partial update values.
   * @returns Updated row or null when absent.
   */
  update(args: UpdateArgs<T>): Promise<Row<T> | null>;

  /**
   * Selects then inserts or updates using portable dialect semantics.
   * @param args - Unique selector and create/update branches.
   * @returns Resulting row; this portable read/write sequence is not an atomic SQL upsert.
   */
  upsert(args: UpsertArgs<T>): Promise<Row<T>>;

  /**
   * Removes one selected row without automatic retries.
   * @param args - Complete unique selector.
   * @returns Deleted row or null when absent.
   */
  delete(args: DeleteArgs<T>): Promise<Row<T> | null>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L88)

### DeleteArgs (interface)

Complete unique selector for deletion.

**Signature**

```ts
export interface DeleteArgs<T extends Table> {
  readonly where: Where<T>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L80)

### FindManyArgs (interface)

Bounded ordered page filters; default limit is 100.

**Signature**

```ts
export interface FindManyArgs<T extends Table> {
  readonly where?: Where<T>;
  readonly orderBy?: {
    readonly field: Extract<keyof Row<T>, string>;
    readonly direction: "asc" | "desc";
  };
  readonly limit?: number;
  readonly offset?: number;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L39)

### FindOneArgs (interface)

Complete unique selector for one row.

**Signature**

```ts
export interface FindOneArgs<T extends Table> {
  readonly where: Where<T>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L31)

### Insert (type alias)

Insert values retaining nullable, default and generated-column inference.

**Signature**

```ts
type Insert<T extends Table> = InferInsertModel<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L13)

### InsertArgs (interface)

Single-row insertion values.

**Signature**

```ts
export interface InsertArgs<T extends Table> {
  readonly data: Insert<T>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L53)

### Row (type alias)

Persisted row inferred from a table.

**Signature**

```ts
type Row<T extends Table> = InferSelectModel<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L7)

### Update (type alias)

Partial insert-compatible update values.

**Signature**

```ts
type Update<T extends Table> = Partial<Insert<T>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L19)

### UpdateArgs (interface)

Complete selector and partial update values.

**Signature**

```ts
export interface UpdateArgs<T extends Table> {
  readonly where: Where<T>;
  readonly data: Update<T>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L61)

### UpsertArgs (interface)

Selector and separate create/update branches.

**Signature**

```ts
export interface UpsertArgs<T extends Table> {
  readonly where: Where<T>;
  readonly create: Insert<T>;
  readonly update: Update<T>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L70)

### Where (type alias)

Column equality filter; unique operations require a complete selector.

**Signature**

```ts
type Where<T extends Table> = Partial<Row<T>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.types.ts#L25)

## `operations.utils.ts`

### call

Calls a checked native method with its original receiver.

**Throws**

TypeError when the method is unavailable.

**Signature**

```ts
declare const call: (target: unknown, name: string, ...args: unknown[]) => unknown;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L77)

### clause

Builds equality predicates, treating null as SQL IS NULL.

**Throws**

TypeError for undefined values or unknown columns.

**Signature**

```ts
declare const clause: (binding: ModelBinding, where: Record<string, unknown>) => SQL | undefined;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L47)

### columnFor

Resolves one declared column.

**Throws**

TypeError for unknown fields.

**Signature**

```ts
declare const columnFor: (binding: ModelBinding, key: string) => Column;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L63)

### hasMethod

Inspects a native capability without invoking it.

**Signature**

```ts
declare const hasMethod: (target: unknown, name: string) => boolean;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L91)

### integer

Checks bounded pagination without coercing strings.

**Throws**

TypeError for invalid pagination.

**Signature**

```ts
declare const integer: (value: unknown, name: string, fallback: number, maximum?: number) => number;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L118)

### isRecord

Checks argument records without invoking getters.

**Signature**

```ts
declare const isRecord: (value: unknown) => value is Record<string, unknown>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L146)

### record

Requires a plain argument record.

**Throws**

TypeError for null, arrays and scalar arguments.

**Signature**

```ts
declare const record: (value: unknown) => Record<string, unknown>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L104)

### recoverable

Finds a complete key for MySQL row recovery after writes.

**Signature**

```ts
declare const recoverable: (
  binding: ModelBinding,
  value: Record<string, unknown>,
) => Record<string, unknown> | undefined;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L30)

### requiredRow

Requires a successful mutation row.

**Throws**

TypeError when no row was returned.

**Signature**

```ts
declare const requiredRow: (value: unknown) => unknown;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L136)

### selector

Requires a complete non-null unique selector.

**Throws**

TypeError for invalid keys or incomplete uniqueness.

**Signature**

```ts
declare const selector: (binding: ModelBinding, value: unknown) => Record<string, unknown>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/operations.utils.ts#L11)

## `owner.ts`

### DrizzleOwner (class)

Client lifetime/admission contract, substitutable through live/test Layers.

**See**

- `drizzleOwnerLayer` for checked acquisition/provisioning/cleanup composition.

**Signature**

```ts
declare class DrizzleOwner
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L20)

### drizzleInstrumentationOf

Reads the observation context captured at activation.

**Signature**

```ts
declare const drizzleInstrumentationOf: (activation: object) => Context.Context<never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L209)

### drizzleOwnerLayer

Acquires one client into a Layer scope.

**Example**

```ts
import { ManagedRuntime } from "effect";
import { sqliteTable, integer } from "drizzle-orm/sqlite-core";
import { defineDrizzleService } from "@relkit/drizzle";
import { DrizzleOwner, drizzleOwnerLayer, drizzleRuntimeOf } from "@relkit/drizzle/internal";
const records = sqliteTable("records", { id: integer().primaryKey() });
const declaration = drizzleRuntimeOf(
  defineDrizzleService({ schema: { records }, client: () => ({}) }),
);
const owner = ManagedRuntime.make(drizzleOwnerLayer(declaration, {}));
try {
  await owner.runPromise(DrizzleOwner);
} finally {
  await owner.dispose();
}
```

**Signature**

```ts
declare const drizzleOwnerLayer: (
  declaration: DrizzleServiceRuntime,
  env: Readonly<Record<string, unknown>>,
) => Layer.Layer<DrizzleOwner, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L45)

### makeDrizzleOwner

Creates the service contract for live acquisition or deterministic fake clients.

**See**

- `drizzleOwnerLayer` for the owning Layer and execution boundary.

**Signature**

```ts
declare const makeDrizzleOwner: (
  client: unknown,
) => Effect.Effect<DrizzleOwnerInterface, never, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L89)

### owners

Weak association preserving the exact frozen public activation shape.

**Signature**

```ts
declare const owners: WeakMap<object, OwnerBinding>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L25)

### runDrizzleWorkPromise

Executes one admitted Promise compatibility edge.

**See**

- `withDrizzleWork` for the equivalent Effect-native borrowed lease.

**Signature**

```ts
declare const runDrizzleWorkPromise: <A, E>(
  activation: object,
  effect: Effect.Effect<A, E>,
) => Promise<A>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L222)

### withDrizzleWork

Admits lazy work and releases its lease after safe native settlement.

**Example**

````ts
Compose work with an existing activation
```ts
import { Effect } from "effect";
import { activateDrizzleService } from "@relkit/drizzle";
import { withDrizzleWork } from "@relkit/drizzle/internal";
function borrowedWork(active: Awaited<ReturnType<typeof activateDrizzleService>>) {
  return withDrizzleWork(active, Effect.succeed(1));
}
````

````

**Signature**

```ts
declare const withDrizzleWork: <A, E, R>(activation: object, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | DrizzleFailure, R>
````

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.ts#L138)

## `owner.types.ts`

### AdmissionState (interface)

Atomic owner admission state; close is monotonic.

**Signature**

```ts
export interface AdmissionState {
  readonly closing: boolean;
  readonly active: number;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.types.ts#L6)

### DrizzleOwnerInterface (interface)

Shared live/test contract for one client lifetime.

**Signature**

```ts
export interface DrizzleOwnerInterface {
  readonly client: unknown;
  readonly admission: Ref.Ref<AdmissionState>;
  readonly drained: Latch.Latch;

  /**
   * Admits lazy work while preserving its caller requirements and causes.
   * @typeParam A - Successful caller result.
   * @typeParam E - Caller typed failure.
   * @typeParam R - Required caller services.
   * @param effect - SDK adapter work retaining its lease until native settlement.
   * @returns Lazy caller work or a typed closed-owner admission failure.
   */
  readonly work: <A, E, R>(
    effect: Effect.Effect<A, E, R>,
  ) => Effect.Effect<A, E | DrizzleFailure, R>;

  /**
   * Marks admission closed monotonically.
   * @returns Lazy state transition; already admitted work retains its lease.
   */
  readonly beginClose: () => Effect.Effect<void>;

  /**
   * Awaits all previously admitted native work.
   * @returns Lazy drain barrier; resource disposal must follow this completion.
   */
  readonly awaitDrained: () => Effect.Effect<void>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.types.ts#L12)

### OwnerBinding (interface)

Private association; the public activation remains frozen.

**Signature**

```ts
export interface OwnerBinding {
  readonly dialect: "sqlite" | "pg" | "mysql";
  readonly service: DrizzleOwnerInterface;
  readonly runtime: ManagedRuntime.ManagedRuntime<DrizzleOwner, DrizzleFailure>;
  readonly instrumentation: Context.Context<never>;
  readonly run: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/owner.types.ts#L43)

## `pg.ts`

pg native model typing; imports only this selected dialect's upstream declarations.

### "./index.js" (namespace export)

Re-exports all named exports from the "./index.js" module.

**Signature**

```ts
export * from "./index.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/pg.ts#L5)

### DialectDatabase (type alias)

Native database injected into model extensions for the selected dialect.

**Signature**

```ts
type DialectDatabase = Omit<PgAsyncDatabase<any, any>, "query">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/pg.ts#L8)

### defineModel

Declares lazy native extensions with this dialect's real transaction client type.

**Signature**

```ts
declare const defineModel: DefineModel<DialectDatabase>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/pg.ts#L11)

## `queries.ts`

### checked

Converts expected synchronous argument/native-builder exceptions.

**Signature**

```ts
declare const checked: <A>(run: () => A) => Effect.Effect<A, DrizzleFailure>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/queries.ts#L86)

### findMany

Selects a bounded ordered page.

**Signature**

```ts
declare const findMany: (
  binding: ModelBinding,
  args: Record<string, unknown>,
) => Effect.Effect<Array<unknown>, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/queries.ts#L39)

### findOne

Selects one unique row and validates persisted data.

**Signature**

```ts
declare const findOne: (
  binding: ModelBinding,
  where: Record<string, unknown>,
) => Effect.Effect<{} | null, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/queries.ts#L14)

### rows

Awaits native rows then validates sequentially without starting new SDK work.

**Signature**

```ts
declare const rows: (
  binding: ModelBinding,
  query: unknown,
) => Effect.Effect<Array<unknown>, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/queries.ts#L69)

## `runtime-types.ts`

### DRIZZLE_RUNTIME

Stable hidden descriptor brand; shared across module copies.

**Signature**

```ts
declare const DRIZZLE_RUNTIME: unique symbol;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/runtime-types.ts#L8)

### DrizzleServiceRuntime (interface)

Pure declaration dependencies; accessing this object never acquires a client.

**Signature**

```ts
export interface DrizzleServiceRuntime {
  readonly client: (context: { readonly env: Readonly<Record<string, unknown>> }) => unknown;
  readonly dispose?: (database: any) => unknown;
  readonly schema: Readonly<Record<string, unknown>>;
  readonly tables: TableMap;
  readonly models: DrizzleModelMap<TableMap>;
  readonly overrides: DrizzleOverrides<TableMap>;
  readonly metadata: Readonly<Record<string, TableMetadata>>;
  readonly zodSchemas: Readonly<Record<string, TableZodSchemas<Table>>>;
  readonly effectSchemas: Readonly<Record<string, ReturnType<typeof effectSchemasFor>>>;
  readonly dialect: "pg" | "mysql" | "sqlite";
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/runtime-types.ts#L26)

### MODEL_RUNTIME

Stable hidden model descriptor brand.

**Signature**

```ts
declare const MODEL_RUNTIME: unique symbol;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/runtime-types.ts#L11)

### ModelBinding (interface)

Table operations bound to an owner or an already admitted transaction.

**Signature**

```ts
export interface ModelBinding {
  /**
   * Executes work at its owning runtime edge.
   * @typeParam A - Successful result.
   * @param effect - Lazy typed operation.
   * @param operation - Bounded diagnostic label.
   * @returns Public result or original native failure.
   */
  readonly run: <A>(effect: Effect.Effect<A, DrizzleFailure>, operation: string) => Promise<A>;
  readonly drizzle: unknown;
  readonly table: Table;
  readonly dialect: "pg" | "mysql" | "sqlite";
  readonly inTransaction: boolean;
  readonly metadata: TableMetadata;
  readonly override: Readonly<Record<string, unknown>>;
  readonly schemas: ReturnType<typeof effectSchemasFor>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/runtime-types.ts#L40)

### ModelRuntime (interface)

Opaque authored extensions retaining their native injected database contract.

**Signature**

```ts
export interface ModelRuntime {
  readonly table: Table;
  readonly extend: Readonly<Record<string, (context: any, ...args: any[]) => unknown>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/runtime-types.ts#L20)

### TableMetadata (interface)

Pure table-column and complete unique-selector metadata.

**Signature**

```ts
export interface TableMetadata {
  readonly columns: Readonly<Record<string, unknown>>;
  readonly selectors: readonly (readonly string[])[];
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/runtime-types.ts#L14)

## `service.ts`

### defineDrizzleService

Defines the application's Drizzle service, table operations, and model customizations.
The client factory runs at activation, not during descriptor discovery.

**Throws**

TypeError for invalid declarations, dialects, models or overrides.

**Example**

```ts
import { defineDrizzleService } from "@relkit/drizzle";
import { integer, sqliteTable } from "drizzle-orm/sqlite-core";

const users = sqliteTable("users", { id: integer().primaryKey() });
const service = defineDrizzleService({
  schema: { users },
  client: () => {
    throw new Error("Configure a Drizzle driver before activation");
  },
});
console.assert(service.capability.dialect === "sqlite");
```

**Signature**

```ts
declare const defineDrizzleService: <
  Client,
  const Schema extends Readonly<Record<string, unknown>>,
  const Models extends DrizzleModelMap<TablesOf<Schema>> = {},
>(
  options: DefineDrizzleServiceOptions<Client, Schema, Models>,
) => DrizzleServiceDescriptor<string, Client, Schema, Models>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/service.ts#L39)

Since v0.1.0

### DefineDrizzleServiceOptions

**Signature**

```ts
declare const DefineDrizzleServiceOptions: DefineDrizzleServiceOptions<Client, Schema, Models>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/service.ts#L12)

### drizzleRuntimeOf

Resolves hidden runtime metadata without acquiring a client.

**Throws**

TypeError for unbranded declarations.

**Signature**

```ts
declare const drizzleRuntimeOf: (value: object) => DrizzleServiceRuntime;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/service.ts#L136)

## `service.types.ts`

### DefineDrizzleServiceOptions (interface)

Lazy authoring options preserving native client and model extension inference.

**Signature**

```ts
export interface DefineDrizzleServiceOptions<
  Client,
  Schema extends Readonly<Record<string, unknown>>,
  Models extends DrizzleModelMap<TablesOf<Schema>>,
> {
  readonly id?: string;
  readonly schema: Schema;
  /**
   * Acquires a native client when the owner Layer is first built.
   * @param context - First activation environment.
   * @returns Native client or acquisition Promise; failures retain native identity.
   */
  readonly client: (context: { readonly env: ApplicationEnv }) => Client | Promise<Client>;
  readonly models?: Models;
  readonly overrides?: DrizzleOverrides<TablesOf<Schema>>;
  /**
   * Releases the owned native client once admitted work has drained.
   * @param database - Successfully acquired client.
   * @returns Optional native completion; failure remains visible at close.
   */
  readonly dispose?: (database: Client) => unknown | Promise<unknown>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/service.types.ts#L9)

## `sqlite.ts`

sqlite native model typing; imports only this selected dialect's upstream declarations.

### "./index.js" (namespace export)

Re-exports all named exports from the "./index.js" module.

**Signature**

```ts
export * from "./index.js";
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/sqlite.ts#L5)

### DialectDatabase (type alias)

Native database injected into model extensions for the selected dialect.

**Signature**

```ts
type DialectDatabase = Omit<SQLiteAsyncDatabase<any, any, any>, "query">;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/sqlite.ts#L8)

### defineModel

Declares lazy native extensions with this dialect's real transaction client type.

**Signature**

```ts
declare const defineModel: DefineModel<DialectDatabase>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/sqlite.ts#L11)

## `table.schemas.ts`

### decodeTableValue

Validates unknown native rows or write data at the domain boundary.

**Signature**

```ts
declare const decodeTableValue: (
  schema: Schema.Codec<unknown, unknown>,
  value: unknown,
) => Effect.Effect<unknown, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/table.schemas.ts#L67)

### effectSchemasFor

Generates pinned Drizzle/Effect contracts without acquiring a database.

**Signature**

```ts
declare const effectSchemasFor: (table: Table) => Readonly<{
  select: BuildSchema<"select", Columns, { [x: string]: any }>;
  insert: BuildSchema<"insert", Columns, { [x: string]: any }>;
  update: BuildSchema<
    "update",
    Columns,
    { [k: string]: () => Schema.Codec<unknown, unknown, never, never> }
  >;
}>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/table.schemas.ts#L15)

## `trace-redaction.ts`

### redactSpecializedTrace

Protects configured tracers without changing authoritative workflow exits.

**Signature**

```ts
declare const redactSpecializedTrace: <A, E, R>(
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, E, Exclude<R, never>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/trace-redaction.ts#L13)

### specializedTracer

Adapts span completion before an external exporter can inspect native causes.

**Signature**

```ts
declare const specializedTracer: (tracer: Tracer.Tracer) => Tracer.Tracer;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/trace-redaction.ts#L24)

## `transaction.ts`

### transactionEffect

Executes a portable transaction under the physical SQLite client lock.

**Signature**

```ts
declare const transactionEffect: <A>(
  database: unknown,
  dialect: "sqlite" | "pg" | "mysql",
  run: (database: unknown, lease: NativeLease) => Promise<A>,
) => Effect.Effect<A, DrizzleFailure, never>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/transaction.ts#L23)

### withSqlitePermit

Serializes conflicting SQLite work at the physical client boundary.

**Signature**

```ts
declare const withSqlitePermit: <A, E, R>(
  database: unknown,
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, E | DrizzleFailure, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/transaction.ts#L121)

### withTransactionWork

Retains a transaction callback while one child operation executes.

**Signature**

```ts
declare const withTransactionWork: <A, E, R>(
  lease: NativeLease,
  effect: Effect.Effect<A, E, R>,
) => Effect.Effect<A, DrizzleFailure | E, R>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/transaction.ts#L95)

## `types.ts`

Portable database contracts; native model database types belong to selected dialect entrypoints.

### ApplicationEnv (type alias)

Application declaration augmentation, falling back to string environment values.

**Signature**

```ts
type ApplicationEnv = keyof Relkit.ApplicationEnv extends never
  ? Readonly<Record<string, string>>
  : Readonly<Relkit.ApplicationEnv>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L116)

### BaseOperations

**Signature**

```ts
declare const BaseOperations: BaseOperations<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L41)

### DatabaseContext (type alias)

Public transaction-aware table operations and unchanged Zod schemas.

**Signature**

```ts
type DatabaseContext<Service extends DrizzleServiceDescriptor<any, any, any, any>> = {
  readonly [Name in keyof TablesOf<Service[typeof SERVICE_TYPES]["schema"]>]: BaseOperations<
    TablesOf<Service[typeof SERVICE_TYPES]["schema"]>[Name]
  > &
    (Name extends keyof Service[typeof SERVICE_TYPES]["models"]
      ? ConsumerExtensions<Service[typeof SERVICE_TYPES]["models"][Name]>
      : {});
} & {
  /**
   * Runs a callback in a portable transaction without nested portable transactions.
   * @typeParam Value - Callback result.
   * @param run - Callback receiving transaction-bound table operations.
   * @returns Callback result after native commit, or original failure after rollback.
   */
  readonly transaction: <Value>(
    run: (context: DatabaseContext<Service>) => MaybePromise<Value>,
  ) => Promise<Value>;
  readonly zodSchemas: {
    readonly [Name in keyof TablesOf<Service[typeof SERVICE_TYPES]["schema"]>]: TableZodSchemas<
      TablesOf<Service[typeof SERVICE_TYPES]["schema"]>[Name]
    >;
  };
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L168)

### DeleteArgs

**Signature**

```ts
declare const DeleteArgs: DeleteArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L40)

### DrizzleCapability (interface)

Pure compiler-visible dialect, tables, constraints and custom methods.

**Signature**

```ts
export interface DrizzleCapability {
  readonly kind: "drizzle";
  readonly dialect: "pg" | "mysql" | "sqlite";
  readonly tables: readonly {
    readonly name: string;
    readonly databaseName: string;
    readonly columns: readonly {
      readonly key: string;
      readonly name: string;
      readonly dataType: string;
      readonly notNull: boolean;
      readonly hasDefault: boolean;
      readonly primaryKey: boolean;
      readonly unique: boolean;
    }[];
    readonly selectors: readonly (readonly string[])[];
    readonly customMethods: readonly string[];
  }[];
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L121)

### DrizzleModelMap (type alias)

Optional table-keyed model declarations.

**Signature**

```ts
type DrizzleModelMap<Tables extends TableMap> = Partial<{
  readonly [Name in keyof Tables]: ModelDescriptor<Tables[Name], any>;
}>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L79)

### DrizzleOverrides (type alias)

Table-keyed override declarations.

**Signature**

```ts
type DrizzleOverrides<Tables extends TableMap> = {
  readonly [Name in keyof Tables]?: TableOverrides<Tables[Name]>;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L71)

### DrizzleServiceDescriptor (type alias)

Frozen service descriptor retaining native client, schema and model inference.

**Signature**

```ts
type DrizzleServiceDescriptor<
  Id extends string,
  Client,
  Schema,
  Models extends DrizzleModelMap<TablesOf<Schema>>,
> = DescriptorBase<"service", Id> & {
  readonly capability: DrizzleCapability;
  readonly [SERVICE_TYPES]: {
    readonly client: Client;
    readonly schema: Schema;
    readonly models: Models;
  };
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L150)

### FindManyArgs

**Signature**

```ts
declare const FindManyArgs: FindManyArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L36)

### FindOneArgs

**Signature**

```ts
declare const FindOneArgs: FindOneArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L35)

### Insert

**Signature**

```ts
declare const Insert: {
  [
    K in keyof ({
      [
        Key in keyof T["_"]["columns"] & string as RequiredKeyOnly<Key, T["_"]["columns"][Key]>
      ]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    } & {
      [
        Key in keyof T["_"]["columns"] & string as OptionalKeyOnly<
          Key,
          T["_"]["columns"][Key],
          false
        >
      ]?:
        | (T["_"]["columns"][Key]["_"]["notNull"] extends true
            ? T["_"]["columns"][Key]["_"]["data"]
            : T["_"]["columns"][Key]["_"]["data"] | null)
        | undefined;
    })
  ]: ({
    [
      Key in keyof T["_"]["columns"] & string as RequiredKeyOnly<Key, T["_"]["columns"][Key]>
    ]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  } & {
    [
      Key in keyof T["_"]["columns"] & string as OptionalKeyOnly<Key, T["_"]["columns"][Key], false>
    ]?:
      | (T["_"]["columns"][Key]["_"]["notNull"] extends true
          ? T["_"]["columns"][Key]["_"]["data"]
          : T["_"]["columns"][Key]["_"]["data"] | null)
      | undefined;
  })[K];
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L32)

### InsertArgs

**Signature**

```ts
declare const InsertArgs: InsertArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L37)

### ModelDescriptor

**Signature**

```ts
declare const ModelDescriptor: ModelDescriptor<T, Extensions>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L8)

### ModelDescriptorAny

**Signature**

```ts
declare const ModelDescriptorAny: ModelDescriptorAny;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L9)

### ModelExtension

**Signature**

```ts
declare const ModelExtension: ModelExtension<T, Database>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L10)

### ModelExtensionContext

**Signature**

```ts
declare const ModelExtensionContext: ModelExtensionContext<T, Database>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L11)

### ModelExtensionMap

**Signature**

```ts
declare const ModelExtensionMap: Readonly<Record<string, ModelExtension<T, Database>>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L12)

### NonEmptyExtensions

**Signature**

```ts
declare const NonEmptyExtensions: NonEmptyExtensions<Extensions>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L13)

### OperationOverride (type alias)

Native override receiving a Promise base operation.

**Signature**

```ts
type OperationOverride<Args, Result> = (options: {
  readonly args: Args;
  readonly base: (args: Args) => Promise<Result>;
}) => MaybePromise<Result>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L51)

### Row

**Signature**

```ts
declare const Row: {
  [
    K in keyof {
      [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    }
  ]: {
    [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  }[K];
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L31)

### TableMap (type alias)

Supported tables keyed by authored schema names.

**Signature**

```ts
type TableMap = Readonly<Record<string, Table>>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L17)

### TableOverrides (type alias)

Optional replacements for the six reserved table operations.

**Signature**

```ts
type TableOverrides<T extends Table> = {
  readonly [Name in keyof BaseOperations<T>]?: OperationOverride<
    Parameters<BaseOperations<T>[Name]>[0],
    Awaited<ReturnType<BaseOperations<T>[Name]>>
  >;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L60)

### TableZodSchemas (interface)

Unchanged public select, insert and update Zod contracts.

**Signature**

```ts
export interface TableZodSchemas<T extends Table> {
  readonly select: ZodType<Row<T>>;
  readonly insert: ZodType<Insert<T>>;
  readonly update: ZodType<Update<T>>;
}
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L103)

### TablesOf (type alias)

Table-only projection of an authored Drizzle schema.

**Signature**

```ts
type TablesOf<Schema> = {
  readonly [Name in keyof Schema as Schema[Name] extends Table ? Name : never]: Extract<
    Schema[Name],
    Table
  >;
};
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L23)

### Update

**Signature**

```ts
declare const Update: Partial<{
  [
    K in keyof ({
      [
        Key in keyof T["_"]["columns"] & string as RequiredKeyOnly<Key, T["_"]["columns"][Key]>
      ]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    } & {
      [
        Key in keyof T["_"]["columns"] & string as OptionalKeyOnly<
          Key,
          T["_"]["columns"][Key],
          false
        >
      ]?:
        | (T["_"]["columns"][Key]["_"]["notNull"] extends true
            ? T["_"]["columns"][Key]["_"]["data"]
            : T["_"]["columns"][Key]["_"]["data"] | null)
        | undefined;
    })
  ]: ({
    [
      Key in keyof T["_"]["columns"] & string as RequiredKeyOnly<Key, T["_"]["columns"][Key]>
    ]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  } & {
    [
      Key in keyof T["_"]["columns"] & string as OptionalKeyOnly<Key, T["_"]["columns"][Key], false>
    ]?:
      | (T["_"]["columns"][Key]["_"]["notNull"] extends true
          ? T["_"]["columns"][Key]["_"]["data"]
          : T["_"]["columns"][Key]["_"]["data"] | null)
      | undefined;
  })[K];
}>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L33)

### UpdateArgs

**Signature**

```ts
declare const UpdateArgs: UpdateArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L38)

### UpsertArgs

**Signature**

```ts
declare const UpsertArgs: UpsertArgs<T>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L39)

### Where

**Signature**

```ts
declare const Where: Partial<{
  [
    K in keyof {
      [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
        ? T["_"]["columns"][Key]["_"]["data"]
        : T["_"]["columns"][Key]["_"]["data"] | null;
    }
  ]: {
    [Key in keyof T["_"]["columns"] & string]: T["_"]["columns"][Key]["_"]["notNull"] extends true
      ? T["_"]["columns"][Key]["_"]["data"]
      : T["_"]["columns"][Key]["_"]["data"] | null;
  }[K];
}>;
```

[Source](https://github.com/rel-kit/relkit/blob/main/packages/drizzle/src/types.ts#L34)