equipped 5.2.9 → 5.3.0

package/dist/types/instance/index.js

@@ -1,136 +1,8 @@
-import pino, {} from "pino";
-import { ulid } from "ulid";
-import { v } from "valleyed";
-import { EquippedError } from "../errors/index.js";
-import { runHooks } from "./hooks.js";
 import {
-  cachePipe,
-  dbPipe,
-  eventBusPipe,
-  instanceSettingsPipe,
-  jobsPipe,
-  serverTypePipe
-} from "./settings.js";
-class Instance {
-  static #id;
-  static #instance;
-  static #hooks = {};
-  settings;
-  log;
-  constructor(settings) {
-    Instance.#instance = this;
-    this.settings = Object.freeze(settings);
-    this.log = pino({
-      level: this.settings.log.level,
-      serializers: {
-        err: pino.stdSerializers.err,
-        error: pino.stdSerializers.err,
-        req: pino.stdSerializers.req,
-        res: pino.stdSerializers.res
-      },
-      mixin: () => ({
-        instanceId: Instance.#id
-      })
-    });
-    Instance.#registerOnExitHandler();
-  }
-  alias(id) {
-    if (Instance.#id !== void 0) return Instance.crash(new EquippedError("Instance already has an alias", {}));
-    Instance.#id = id;
-  }
-  get id() {
-    if (Instance.#id === void 0) return Instance.crash(new EquippedError("Instance doesnt have an alias yet", {}));
-    return Instance.#id;
-  }
-  getScopedName(name, key = ".") {
-    return [this.settings.app.name, name].join(key);
-  }
-  createCache(input) {
-    return v.assert(cachePipe(), input);
-  }
-  createJobs(input) {
-    return v.assert(jobsPipe(), input);
-  }
-  createEventBus(input) {
-    return v.assert(eventBusPipe(), input);
-  }
-  createDb(input) {
-    return v.assert(dbPipe(), input);
-  }
-  createServer(input) {
-    return v.assert(serverTypePipe(), input);
-  }
-  async start() {
-    try {
-      await runHooks(Instance.#hooks["setup"] ?? []);
-      await runHooks(Instance.#hooks["start"] ?? []);
-    } catch (error) {
-      Instance.crash(new EquippedError(`Error starting instance`, {}, error));
-    }
-  }
-  static envs(envsPipe) {
-    const envValidity = v.validate(envsPipe, process.env);
-    if (!envValidity.valid) {
-      Instance.crash(
-        new EquippedError(`Environment variables are not valid
-${envValidity.error.toString()}`, {
-          messages: envValidity.error.messages
-        })
-      );
-    }
-    return envValidity.value;
-  }
-  static create(settings) {
-    if (Instance.#instance) return Instance.crash(new EquippedError("Instance has been initialized already", {}));
-    const settingsValidity = v.validate(instanceSettingsPipe(), settings);
-    if (!settingsValidity.valid) {
-      Instance.crash(
-        new EquippedError(`Settings are not valid
-${settingsValidity.error.toString()}`, {
-          messages: settingsValidity.error.messages
-        })
-      );
-    }
-    return new Instance(settingsValidity.value);
-  }
-  static get() {
-    if (!Instance.#instance)
-      return Instance.crash(
-        new EquippedError("Has not been initialized. Make sure an instance has been created before you get an instance", {})
-      );
-    return Instance.#instance;
-  }
-  static on(event, cb, order) {
-    Instance.#hooks[event] ??= [];
-    Instance.#hooks[event].push({ cb, order });
-  }
-  static #registerOnExitHandler() {
-    const signals = {
-      SIGHUP: 1,
-      SIGINT: 2,
-      SIGTERM: 15
-    };
-    Object.entries(signals).forEach(([signal, code]) => {
-      process.on(signal, async () => {
-        await runHooks(Instance.#hooks["close"] ?? [], () => {
-        });
-        process.exit(128 + code);
-      });
-    });
-  }
-  static resolveBeforeCrash(cb) {
-    const value = cb();
-    Instance.on("close", async () => await value, 10);
-    return value;
-  }
-  static crash(error) {
-    console.error(error);
-    process.exit(1);
-  }
-  static createId(opts) {
-    return `${opts?.prefix ?? ""}${ulid(opts?.time?.getTime())}`;
-  }
-}
+  Instance
+} from "../chunk-YTY3EFNB.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
 export {
   Instance
 };

package/dist/types/introspection-VOIU3XE6.js

@@ -0,0 +1,9 @@
+import {
+  OrmIntrospectionError
+} from "./chunk-OHFTQGQG.js";
+import "./chunk-YTY3EFNB.js";
+import "./chunk-KZKFYO4V.js";
+import "./chunk-MLKGABMK.js";
+export {
+  OrmIntrospectionError
+};

package/dist/types/jobs/adapters/redis/index.d.ts

@@ -0,0 +1,93 @@
+import * as valleyed from 'valleyed';
+import { Job, DelayedJobEvent, RepeatableJobEvent } from '../../index.js';
+import '../../../overrides-6Hxg764S.js';
+
+declare const redisJobsConfigPipe: () => valleyed.Pipe<{
+    redisConfig: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    queueName: string;
+}, {
+    redisConfig: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    queueName: string;
+}>;
+declare const RedisJob_base: (abstract new (validated: {
+    redisConfig: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    queueName: string;
+}) => Job & {
+    readonly config: {
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    };
+}) & {
+    readonly Config: {
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        redisConfig: {
+            host: string;
+            port?: number | undefined;
+            password?: string | undefined;
+            username?: string | undefined;
+            tls?: boolean | undefined;
+            cluster?: boolean | undefined;
+        };
+        queueName: string;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class RedisJob extends RedisJob_base {
+    #private;
+    protected constructor(config: typeof RedisJob.Config);
+    addDelayed(data: DelayedJobEvent, delayInMs: number): Promise<string>;
+    addRepeatable(data: RepeatableJobEvent, cron: string, tz?: string): Promise<string>;
+    removeDelayed(jobId: string): Promise<void>;
+    retryAllFailedJobs(): Promise<void>;
+}
+
+export { RedisJob, redisJobsConfigPipe };

package/dist/types/jobs/{types/redis.js → adapters/redis/index.js}

@@ -1,60 +1,84 @@
+import {
+  RedisCache,
+  redisConfigPipe
+} from "../../../chunk-65EHKCDZ.js";
+import "../../../chunk-3TKJGSCZ.js";
+import {
+  Job
+} from "../../../chunk-LN3A6R4Y.js";
+import {
+  Instance,
+  configurable,
+  random_exports
+} from "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/jobs/adapters/redis/index.ts
 import { Queue, Worker } from "bullmq";
-import { RedisCache } from "../../cache/types/redis.js";
-import { Instance } from "../../instance/index.js";
-import { Random } from "../../utilities/index.js";
-var JobNames = /* @__PURE__ */ ((JobNames2) => {
-  JobNames2["CronJob"] = "CronJob";
-  JobNames2["RepeatableJob"] = "RepeatableJob";
-  JobNames2["DelayedJob"] = "DelayedJob";
-  return JobNames2;
-})(JobNames || {});
-class RedisJob {
+import { v } from "valleyed";
+var redisJobsConfigPipe = () => v.meta(
+  v.object({
+    redisConfig: redisConfigPipe(),
+    queueName: v.string()
+  }),
+  { title: "Redis Jobs Config", $refId: "RedisJobsConfig" }
+);
+var RedisJob = class _RedisJob extends configurable(redisJobsConfigPipe, Job) {
   #queue;
-  #callbacks = {};
-  #crons = [];
   constructor(config) {
-    const redisCache = new RedisCache(config.redisConfig, {
+    super(config);
+    const redisCache = RedisCache.create(config.redisConfig, {
       maxRetriesPerRequest: null,
       enableReadyCheck: false
     });
     const queueName = Instance.get().getScopedName(config.queueName);
-    this.#queue = new Queue(queueName, { connection: redisCache.client.options, skipVersionCheck: true });
+    this.#queue = new Queue(queueName, { connection: redisCache.connectionOptions, skipVersionCheck: true });
     const worker = new Worker(
       queueName,
       async (job) => {
         switch (job.name) {
           case "DelayedJob" /* DelayedJob */:
-            return this.#callbacks.onDelayed?.(job.data);
+            return this.callbacks.onDelayed?.(job.data);
           case "CronJob" /* CronJob */:
-            return this.#callbacks.onCron?.(job.data.type);
+            return this.callbacks.onCron?.(job.data.type);
           case "RepeatableJob" /* RepeatableJob */:
-            return this.#callbacks.onRepeatable?.(job.data);
+            return this.callbacks.onRepeatable?.(job.data);
         }
       },
-      { connection: redisCache.client.options, autorun: false, skipVersionCheck: true }
-    );
-    Instance.on(
-      "start",
-      async () => {
-        await this.#cleanup();
-        await Promise.all(this.#crons.map(({ cron, name }) => this.#addCron(name, cron)));
-        worker.run();
-      },
-      10
+      { connection: redisCache.connectionOptions, autorun: false, skipVersionCheck: true }
     );
+    Instance.on("start", async () => {
+      await this.#cleanup();
+      await Promise.all(this.crons.map(({ cron, name }) => this.#addCron(name, cron)));
+      worker.run();
+    }, { class: _RedisJob });
   }
-  set callbacks(callbacks) {
-    this.#callbacks = callbacks;
+  #getNewId() {
+    return [Date.now(), random_exports.string()].join("_");
   }
-  set crons(crons) {
-    this.#crons = crons;
+  async #addCron(type, cron) {
+    const job = await this.#queue.add(
+      "CronJob" /* CronJob */,
+      { type },
+      {
+        jobId: this.#getNewId(),
+        repeat: { pattern: cron },
+        removeOnComplete: true,
+        backoff: 1e3,
+        attempts: 3
+      }
+    );
+    return job.id.toString();
   }
-  static #getNewId() {
-    return [Date.now(), Random.string()].join("_");
+  async #cleanup() {
+    await this.retryAllFailedJobs();
+    const repeatableJobs = await this.#queue.getJobSchedulers();
+    await Promise.all(repeatableJobs.map((job) => this.#queue.removeJobScheduler(job.key)));
   }
   async addDelayed(data, delayInMs) {
     const job = await this.#queue.add("DelayedJob" /* DelayedJob */, data, {
-      jobId: RedisJob.#getNewId(),
+      jobId: this.#getNewId(),
       delay: delayInMs,
       removeOnComplete: true,
       backoff: 1e3,
@@ -64,7 +88,7 @@ class RedisJob {
   }
   async addRepeatable(data, cron, tz) {
     const job = await this.#queue.add("RepeatableJob" /* RepeatableJob */, data, {
-      jobId: RedisJob.#getNewId(),
+      jobId: this.#getNewId(),
       repeat: { pattern: cron, ...tz ? { tz } : {} },
       removeOnComplete: true,
       backoff: 1e3,
@@ -80,26 +104,17 @@ class RedisJob {
     const failedJobs = await this.#queue.getFailed();
     await Promise.all(failedJobs.map((job) => job.retry()));
   }
-  async #addCron(type, cron) {
-    const job = await this.#queue.add(
-      "CronJob" /* CronJob */,
-      { type },
-      {
-        jobId: RedisJob.#getNewId(),
-        repeat: { pattern: cron },
-        removeOnComplete: true,
-        backoff: 1e3,
-        attempts: 3
-      }
-    );
-    return job.id.toString();
-  }
-  async #cleanup() {
-    await this.retryAllFailedJobs();
-    const repeatableJobs = await this.#queue.getJobSchedulers();
-    await Promise.all(repeatableJobs.map((job) => this.#queue.removeJobScheduler(job.key)));
-  }
+};
+if (void 0) {
+  const { test, expectTypeOf } = void 0;
+  test("external new is a compile error", () => {
+    void (() => new RedisJob({ redisConfig: { host: "" }, queueName: "" }));
+  });
+  test("Config type matches pipe output", () => {
+    expectTypeOf().toEqualTypeOf();
+  });
 }
 export {
-  RedisJob
+  RedisJob,
+  redisJobsConfigPipe
 };

package/dist/types/jobs/index.d.ts

@@ -1,30 +1,10 @@
-import * as valleyed from 'valleyed';
-import { PipeOutput } from 'valleyed';
-import { D as DelayedJobs, C as CronTypes, R as RepeatableJobs } from '../overrides-6Hxg764S.js';
-
-declare const redisJobsConfigPipe: () => valleyed.Pipe<{
-    redisConfig: {
-        host: string;
-        port: number | undefined;
-        password: string | undefined;
-        username: string | undefined;
-        tls: boolean | undefined;
-        cluster: boolean | undefined;
-    };
-    queueName: string;
-}, {
-    redisConfig: {
-        host: string;
-        port: number | undefined;
-        password: string | undefined;
-        username: string | undefined;
-        tls: boolean | undefined;
-        cluster: boolean | undefined;
-    };
-    queueName: string;
-}>;
-type RedisJobConfig = PipeOutput<ReturnType<typeof redisJobsConfigPipe>>;
+import { C as CronTypes, D as DelayedJobs, R as RepeatableJobs } from '../overrides-6Hxg764S.js';
 
+declare enum JobNames {
+    CronJob = "CronJob",
+    RepeatableJob = "RepeatableJob",
+    DelayedJob = "DelayedJob"
+}
 type Cron = CronTypes[keyof CronTypes];
 type DelayedJobEvent = DelayedJobs[keyof DelayedJobs];
 type RepeatableJobEvent = RepeatableJobs[keyof RepeatableJobs];
@@ -36,18 +16,22 @@ type JobCallbacks = {
     onCron?: CronJobCallback;
     onRepeatable?: RepeatableJobCallback;
 };
-declare class RedisJob {
+declare abstract class Job {
     #private;
-    constructor(config: RedisJobConfig);
-    set callbacks(callbacks: JobCallbacks);
-    set crons(crons: {
+    abstract addDelayed(data: DelayedJobEvent, delayInMs: number): Promise<string>;
+    abstract addRepeatable(data: RepeatableJobEvent, cron: string, tz?: string): Promise<string>;
+    abstract removeDelayed(jobId: string): Promise<void>;
+    abstract retryAllFailedJobs(): Promise<void>;
+    get callbacks(): JobCallbacks;
+    set callbacks(newCallbacks: JobCallbacks);
+    get crons(): {
+        name: Cron;
+        cron: string;
+    }[];
+    set crons(newCrons: {
         name: Cron;
         cron: string;
     }[]);
-    addDelayed(data: DelayedJobEvent, delayInMs: number): Promise<string>;
-    addRepeatable(data: RepeatableJobEvent, cron: string, tz?: string): Promise<string>;
-    removeDelayed(jobId: string): Promise<void>;
-    retryAllFailedJobs(): Promise<void>;
 }
 
-export { RedisJob, type RedisJobConfig, redisJobsConfigPipe };
+export { type Cron, type CronJobCallback, type DelayedJobCallback, type DelayedJobEvent, Job, type JobCallbacks, JobNames, type RepeatableJobCallback, type RepeatableJobEvent };

package/dist/types/jobs/index.js

@@ -1,2 +1,9 @@
-export * from "./pipes.js";
-export * from "./types/redis.js";
+import {
+  Job,
+  JobNames
+} from "../chunk-LN3A6R4Y.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Job,
+  JobNames
+};

package/dist/types/orm/adapters/in-memory/index.d.ts

@@ -0,0 +1,92 @@
+import * as valleyed from 'valleyed';
+import { O as OrmAdapter, k as AnyFieldSpec, l as ForeignKeyAction, A as AnySchema, a as AnyUpdateOp, F as FilterGroup, Q as QueryOptions, I as IterationQueryOptions, b as AggregateSpec, C as CreateTableChange, D as DropTableChange, c as AddFieldChange, d as DropFieldChange, M as ModifyFieldChange, R as RenameTableChange, e as RenameFieldChange, f as AddIndexChange, g as DropIndexChange, h as AddForeignKeyChange, i as DropForeignKeyChange, j as DiscoveredSchema } from '../../../adapter-Coap9ISX.js';
+import '../../../equippedError-Cmo60Kn-.js';
+
+type InMemoryRepoConfig = {
+    table: string;
+    prefix?: string;
+};
+type MigrationRecord = {
+    id: string;
+    appliedAt: number;
+};
+type TableMeta = {
+    pk: {
+        name: string;
+        type: string;
+    };
+    fields: Map<string, AnyFieldSpec>;
+};
+type IndexMeta = {
+    table: string;
+    on: readonly string[];
+    unique: boolean;
+};
+type ForeignKeyMeta = {
+    table: string;
+    on: string;
+    references: {
+        table: string;
+        column: string;
+    };
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+};
+declare const InMemoryAdapter_base: (abstract new (validated: {}) => OrmAdapter & {
+    readonly config: {};
+}) & {
+    readonly Config: {};
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {}, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{}, ...infer R] ? R : never): This["prototype"];
+};
+declare class InMemoryAdapter extends InMemoryAdapter_base {
+    #private;
+    readonly schemaConfigPipe: valleyed.Pipe<{
+        table: string;
+    }, {
+        table: string;
+    }>;
+    readonly supportedFieldTypes: readonly ["string", "number", "boolean", "null", "object", "array", "date"];
+    readonly queryableOps: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "in", "notIn", "like", "exists", "notExists", "contains", "notContains"];
+    readonly updateOps: readonly ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+    readonly aggregateOps: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+    readonly stores: Map<string, Map<string, Record<string, unknown>>>;
+    readonly migrations: Map<string, MigrationRecord>;
+    readonly indexes: Map<string, IndexMeta>;
+    readonly tables: Map<string, TableMeta>;
+    readonly foreignKeys: Map<string, ForeignKeyMeta>;
+    protected constructor(config: typeof InMemoryAdapter.Config);
+    findByPk(schema: AnySchema, config: unknown, pk: unknown): Promise<Record<string, unknown> | null>;
+    createMany(schema: AnySchema, config: unknown, data: Record<string, unknown>[]): Promise<Record<string, unknown>[]>;
+    deleteByPk(schema: AnySchema, config: unknown, pk: unknown): Promise<Record<string, unknown> | null>;
+    updateByPk(schema: AnySchema, config: unknown, pk: unknown, ops: AnyUpdateOp[]): Promise<Record<string, unknown> | null>;
+    findMany(schema: AnySchema, config: unknown, group: FilterGroup, options?: QueryOptions): Promise<Record<string, unknown>[]>;
+    count(schema: AnySchema, config: unknown, group: FilterGroup): Promise<number>;
+    iterateMany(schema: AnySchema, config: unknown, group: FilterGroup, options?: IterationQueryOptions): AsyncGenerator<Record<string, unknown>, void, unknown>;
+    updateMany(schema: AnySchema, config: unknown, group: FilterGroup, data: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    deleteMany(schema: AnySchema, config: unknown, filter: FilterGroup): Promise<Record<string, unknown>[]>;
+    upsertOne(schema: AnySchema, config: unknown, filter: FilterGroup, create: Record<string, unknown>, ops: AnyUpdateOp[]): Promise<Record<string, unknown>>;
+    aggregate(schema: AnySchema, config: unknown, spec: AggregateSpec): Promise<Array<Record<string, unknown>>>;
+    loadMigrations(): Promise<{
+        id: string;
+        appliedAt: number;
+    }[]>;
+    recordMigration(id: string, appliedAt: number): Promise<void>;
+    applyCreateTable(change: CreateTableChange<any>): Promise<void>;
+    applyDropTable(change: DropTableChange): Promise<void>;
+    applyAddField(change: AddFieldChange<any>): Promise<void>;
+    applyDropField(change: DropFieldChange): Promise<void>;
+    applyModifyField(change: ModifyFieldChange<any>): Promise<void>;
+    applyRenameTable(change: RenameTableChange): Promise<void>;
+    applyRenameField(change: RenameFieldChange): Promise<void>;
+    applyAddIndex(change: AddIndexChange): Promise<void>;
+    applyDropIndex(change: DropIndexChange): Promise<void>;
+    applyAddForeignKey(change: AddForeignKeyChange): Promise<void>;
+    applyDropForeignKey(change: DropForeignKeyChange): Promise<void>;
+    introspect(): Promise<DiscoveredSchema[]>;
+    acquireMigrationLock<T>(fn: () => Promise<T>): Promise<T>;
+    session<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+export { InMemoryAdapter, type InMemoryRepoConfig };

package/dist/types/orm/adapters/in-memory/index.js

@@ -0,0 +1,10 @@
+import {
+  InMemoryAdapter
+} from "../../../chunk-NJ2FHI3U.js";
+import "../../../chunk-JQ2FWX4W.js";
+import "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+export {
+  InMemoryAdapter
+};

package/dist/types/orm/adapters/json/index.d.ts

@@ -0,0 +1,72 @@
+import * as valleyed from 'valleyed';
+import { O as OrmAdapter, A as AnySchema, a as AnyUpdateOp, F as FilterGroup, Q as QueryOptions, I as IterationQueryOptions, b as AggregateSpec, C as CreateTableChange, D as DropTableChange, c as AddFieldChange, d as DropFieldChange, M as ModifyFieldChange, R as RenameTableChange, e as RenameFieldChange, f as AddIndexChange, g as DropIndexChange, h as AddForeignKeyChange, i as DropForeignKeyChange, j as DiscoveredSchema } from '../../../adapter-Coap9ISX.js';
+import { InMemoryRepoConfig } from '../in-memory/index.js';
+import '../../../equippedError-Cmo60Kn-.js';
+
+type JsonAdapterConfig = InMemoryRepoConfig;
+declare const JsonAdapter_base: (abstract new (validated: {
+    filePath: string;
+}) => OrmAdapter & {
+    readonly config: {
+        filePath: string;
+    };
+}) & {
+    readonly Config: {
+        filePath: string;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        filePath: string;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        filePath: string;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class JsonAdapter extends JsonAdapter_base {
+    #private;
+    readonly schemaConfigPipe: valleyed.Pipe<{
+        table: string;
+    }, {
+        table: string;
+    }>;
+    readonly supportedFieldTypes: readonly ["string", "number", "boolean", "null", "object", "array", "date"];
+    readonly queryableOps: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "in", "notIn", "like", "exists", "notExists", "contains", "notContains"];
+    readonly updateOps: readonly ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+    readonly aggregateOps: readonly ["count", "countDistinct", "sum", "avg", "min", "max"];
+    protected constructor(config: typeof JsonAdapter.Config);
+    get stores(): Map<string, Map<string, Record<string, unknown>>>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    findByPk(schema: AnySchema, config: unknown, pk: unknown): Promise<Record<string, unknown> | null>;
+    createMany(schema: AnySchema, config: unknown, data: Record<string, unknown>[]): Promise<Record<string, unknown>[]>;
+    updateByPk(schema: AnySchema, config: unknown, pk: unknown, ops: AnyUpdateOp[]): Promise<Record<string, unknown> | null>;
+    deleteByPk(schema: AnySchema, config: unknown, pk: unknown): Promise<Record<string, unknown> | null>;
+    findMany(schema: AnySchema, config: unknown, group: FilterGroup, options?: QueryOptions): Promise<Record<string, unknown>[]>;
+    count(schema: AnySchema, config: unknown, group: FilterGroup): Promise<number>;
+    iterateMany(schema: AnySchema, config: unknown, group: FilterGroup, options?: IterationQueryOptions): AsyncGenerator<Record<string, unknown>, void, unknown>;
+    updateMany(schema: AnySchema, config: unknown, group: FilterGroup, data: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    deleteMany(schema: AnySchema, config: unknown, filter: FilterGroup): Promise<Record<string, unknown>[]>;
+    upsertOne(schema: AnySchema, config: unknown, filter: FilterGroup, create: Record<string, unknown>, ops: AnyUpdateOp[]): Promise<Record<string, unknown>>;
+    aggregate(schema: AnySchema, config: unknown, spec: AggregateSpec): Promise<Record<string, unknown>[]>;
+    session<T>(fn: () => Promise<T>): Promise<T>;
+    loadMigrations(): Promise<{
+        id: string;
+        appliedAt: number;
+    }[]>;
+    recordMigration(id: string, appliedAt: number): Promise<void>;
+    acquireMigrationLock<T>(fn: () => Promise<T>): Promise<T>;
+    applyCreateTable(change: CreateTableChange<any>): Promise<void>;
+    applyDropTable(change: DropTableChange): Promise<void>;
+    applyAddField(change: AddFieldChange<any>): Promise<void>;
+    applyDropField(change: DropFieldChange): Promise<void>;
+    applyModifyField(change: ModifyFieldChange<any>): Promise<void>;
+    applyRenameTable(change: RenameTableChange): Promise<void>;
+    applyRenameField(change: RenameFieldChange): Promise<void>;
+    applyAddIndex(change: AddIndexChange): Promise<void>;
+    applyDropIndex(change: DropIndexChange): Promise<void>;
+    applyAddForeignKey(change: AddForeignKeyChange): Promise<void>;
+    applyDropForeignKey(change: DropForeignKeyChange): Promise<void>;
+    introspect(): Promise<DiscoveredSchema[]>;
+}
+
+export { JsonAdapter, type JsonAdapterConfig };