@tstdl/base 0.92.142 → 0.92.144

package/http/server/node/node-http-server.js

@@ -4,21 +4,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
+var _a;
+var NodeHttpServer_1;
 import * as Http from 'node:http';
 import { Writable } from 'node:stream';
 import { bindNodeCallback, share } from 'rxjs';
+import { match, P } from 'ts-pattern';
 import { CancellationToken } from '../../../cancellation/index.js';
 import { disposeAsync } from '../../../disposable/index.js';
 import { HttpHeaders } from '../../../http/http-headers.js';
 import { HttpQuery } from '../../../http/http-query.js';
-import { ResolveArg, Singleton } from '../../../injector/index.js';
+import { afterResolve, inject, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/index.js';
+import { toArray } from '../../../utils/array/array.js';
 import { encodeUtf8 } from '../../../utils/encoding.js';
 import { FeedableAsyncIterable } from '../../../utils/feedable-async-iterable.js';
 import { Timer } from '../../../utils/timer.js';
@@ -26,71 +24,65 @@ import { cancelableTimeout } from '../../../utils/timing.js';
 import { isDefined, isNullOrUndefined, isString } from '../../../utils/type-guards.js';
 import { HttpServerRequest } from '../http-server-request.js';
 import { HttpServer } from '../http-server.js';
-let NodeHttpServer = class NodeHttpServer extends HttpServer {
-    httpServer;
-    sockets;
-    requestIterable;
-    logger;
+import { NodeHttpServerConfiguration } from './module.js';
+let NodeHttpServer = NodeHttpServer_1 = class NodeHttpServer extends HttpServer {
+    #configuration = inject(NodeHttpServerConfiguration);
+    #httpServer = new Http.Server();
+    #sockets = new Set();
+    #requestIterable = new FeedableAsyncIterable();
+    #logger = inject(Logger, NodeHttpServer_1.name);
     untrackConnectedSockets;
     get connectedSocketsCount() {
-        return this.sockets.size;
-    }
-    constructor(logger) {
-        super();
-        this.logger = logger;
-        this.httpServer = new Http.Server();
-        this.sockets = new Set();
-        this.requestIterable = new FeedableAsyncIterable();
-        this.httpServer.on('request', (request, response) => {
-            this.logger.verbose(`${request.method} from "${request.socket.remoteAddress}" to "${request.url}"`);
-            this.requestIterable.feed({ request, response });
-        });
+        return this.#sockets.size;
+    }
+    [afterResolve]() {
+        this.#httpServer.on('request', (request, response) => this.#requestIterable.feed({ request, response }));
     }
     async [disposeAsync]() {
-        if (this.httpServer.listening) {
+        if (this.#httpServer.listening) {
             await this.close(3000);
-            this.requestIterable.end();
+            this.#requestIterable.end();
         }
     }
     async listen(port) {
-        if (this.httpServer.listening) {
+        if (this.#httpServer.listening) {
             throw new Error('http server is already listening');
         }
-        this.httpServer.listen(port);
-        return new Promise((resolve, reject) => {
+        this.#httpServer.listen(port);
+        await new Promise((resolve, reject) => {
             let listeningListener;
-            let errorListener; // eslint-disable-line prefer-const
+            let errorListener;
             listeningListener = () => {
-                this.logger.info(`Listening on port ${port}`);
-                this.untrackConnectedSockets = trackConnectedSockets(this.httpServer, this.sockets);
-                this.httpServer.removeListener('error', errorListener);
+                this.#logger.info(`Listening on port ${port}`);
+                this.untrackConnectedSockets = trackConnectedSockets(this.#httpServer, this.#sockets);
+                this.#httpServer.removeListener('error', errorListener);
                 resolve();
             };
             errorListener = (error) => {
-                this.httpServer.removeListener('listening', listeningListener);
+                this.#httpServer.removeListener('listening', listeningListener);
                 reject(error);
             };
-            this.httpServer.once('listening', listeningListener);
-            this.httpServer.once('error', errorListener);
+            this.#httpServer.once('listening', listeningListener);
+            this.#httpServer.once('error', errorListener);
         });
     }
     async close(timeout) {
-        this.logger.info('Closing http server');
+        this.#logger.info('Closing http server');
         const timer = new Timer(true);
-        const close$ = bindNodeCallback(this.httpServer.close.bind(this.httpServer))().pipe(share());
+        const close$ = bindNodeCallback(this.#httpServer.close.bind(this.#httpServer))().pipe(share());
         close$.subscribe();
         while (true) {
-            const connections = await getConnectionsCount(this.httpServer);
+            const connections = await getConnectionsCount(this.#httpServer);
             if (connections == 0) {
                 break;
             }
             if (timer.milliseconds >= timeout) {
-                this.logger.info(`Force closing of ${connections} remaining sockets after waiting for ${timeout} milliseconds`);
-                destroySockets(this.sockets);
+                this.#logger.info(`Force closing of ${connections} remaining sockets after waiting for ${timeout} milliseconds`);
+                destroySockets(this.#sockets);
                 break;
             }
             if (connections > 0) {
-                this.logger.info(`Waiting for ${connections} connections to end`);
+                this.#logger.info(`Waiting for ${connections} connections to end`);
                 await cancelableTimeout(250, CancellationToken.from(close$));
             }
         }
@@ -98,7 +90,7 @@ let NodeHttpServer = class NodeHttpServer extends HttpServer {
         this.untrackConnectedSockets = undefined;
     }
     async *[Symbol.asyncIterator]() {
-        for await (const { request, response } of this.requestIterable) {
+        for await (const { request, response } of this.#requestIterable) {
             yield this.handleRequest(request, response);
         }
     }
@@ -108,37 +100,35 @@ let NodeHttpServer = class NodeHttpServer extends HttpServer {
         const headers = new HttpHeaders(request.headers);
         const query = HttpQuery.fromURLSearchParams(url.searchParams);
         const context = { nodeRequest: request, nodeResponse: response };
+        const clientIp = getClientIp(request.socket, headers, this.#configuration);
+        this.#logger.verbose(`${request.method} from "${clientIp}" to "${request.url}"`);
         const httpRequest = new HttpServerRequest({
             url,
             method,
             headers,
             query,
-            ip: request.socket.remoteAddress,
-            body: request
+            ip: clientIp,
+            body: request,
         });
         const item = {
             request: httpRequest,
             respond: getResponder(response),
             context,
             async close() {
-                return new Promise((resolve) => response.end(resolve));
-            }
+                await new Promise((resolve) => response.end(resolve));
+            },
         };
         return item;
     }
 };
-NodeHttpServer = __decorate([
-    Singleton(),
-    __param(0, ResolveArg('NodeHttpServer')),
-    __metadata("design:paramtypes", [Logger])
+NodeHttpServer = NodeHttpServer_1 = __decorate([
+    Singleton()
 ], NodeHttpServer);
 export { NodeHttpServer };
-// eslint-disable-next-line max-lines-per-function
 function getResponder(httpResponse) {
-    // eslint-disable-next-line max-statements
     async function respond(response) {
         writeHeaders(response, httpResponse);
-        return writeResponseBody(response, httpResponse);
+        await writeResponseBody(response, httpResponse);
     }
     return respond;
 }
@@ -154,14 +144,16 @@ function writeHeaders(response, httpResponse) {
     }
 }
 async function writeResponseBody(response, httpResponse) {
-    const simpleData = isDefined(response.body?.json) ? JSON.stringify(response.body.json)
-        : isDefined(response.body?.text) ? response.body.text
-            : isDefined(response.body?.buffer) ? response.body.buffer
-                : undefined;
-    const streamData = isDefined(simpleData) ? undefined
-        : isDefined(response.body?.stream) ? response.body.stream
-            : isDefined(response.body?.events) ? response.body.events.readable
-                : undefined;
+    const simpleData = match(response.body)
+        .with({ json: P.select(P.nonNullable) }, (json) => JSON.stringify(json))
+        .with({ text: P.select(P.nonNullable) }, (text) => text)
+        .with({ buffer: P.select(P.nonNullable) }, (buffer) => buffer)
+        .otherwise(() => undefined);
+    const streamData = match(response.body)
+        .when(() => isDefined(simpleData), () => undefined)
+        .with({ stream: P.select(P.nonNullable) }, (stream) => stream)
+        .with({ events: P.select(P.nonNullable) }, (events) => events.readable)
+        .otherwise(() => undefined);
     if (isDefined(simpleData)) {
         const bytes = isString(simpleData) ? encodeUtf8(simpleData) : simpleData;
         if (!httpResponse.hasHeader('Content-Length')) {
@@ -173,12 +165,10 @@ async function writeResponseBody(response, httpResponse) {
         const responseStream = Writable.toWeb(httpResponse);
         await streamData.pipeTo(responseStream);
     }
-    return new Promise((resolve) => {
-        httpResponse.end(resolve);
-    });
+    await new Promise((resolve) => httpResponse.end(resolve));
 }
 async function write(httpResponse, bytes) {
-    return new Promise((resolve, reject) => {
+    await new Promise((resolve, reject) => {
         httpResponse.write(bytes, (error) => {
             if (isNullOrUndefined(error)) {
                 resolve();
@@ -202,7 +192,7 @@ function trackConnectedSockets(server, sockets) {
     return () => server.removeListener('connection', connectionListener);
 }
 async function getConnectionsCount(server) {
-    return new Promise((resolve, reject) => {
+    return await new Promise((resolve, reject) => {
         server.getConnections((error, count) => {
             if (error != undefined) {
                 reject(error);
@@ -217,3 +207,14 @@ function destroySockets(sockets) {
         socket.destroy();
     }
 }
+function getClientIp(socket, headers, configuration) {
+    if (configuration.trustedProxiesCount <= 0) {
+        return socket.remoteAddress;
+    }
+    const xForwardedForHeader = headers.tryGet('X-Forwarded-For');
+    if (isNullOrUndefined(xForwardedForHeader)) {
+        return socket.remoteAddress;
+    }
+    const ips = toArray(xForwardedForHeader).flatMap((value) => value.split(',').map((ip) => ip.trim()).filter((ip) => ip.length > 0));
+    return ips.at(-configuration.trustedProxiesCount) ?? socket.remoteAddress;
+}

package/injector/inject.js

@@ -13,7 +13,7 @@ export function injectMany(...tokens) {
     return getCurrentInjectionContext(injectMany, true).injectMany(...tokens);
 }
 export async function injectAsync(token, argument, options) {
-    return getCurrentInjectionContext(injectAsync, true).injectAsync(token, argument, options);
+    return await getCurrentInjectionContext(injectAsync, true).injectAsync(token, argument, options);
 }
 /**
  * Resolves tokens using the {@link Injector} of the current injection context
@@ -21,7 +21,7 @@ export async function injectAsync(token, argument, options) {
  * @param token tokens to resolve
  */
 export async function injectManyAsync(...tokens) {
-    return getCurrentInjectionContext(injectManyAsync, true).injectManyAsync(...tokens);
+    return await getCurrentInjectionContext(injectManyAsync, true).injectManyAsync(...tokens);
 }
 /**
  * Resolves a token using the {@link Injector} of the current injection context
@@ -41,7 +41,7 @@ export function injectAll(token, argument, options) {
  * @param options resolve options
  */
 export async function injectAllAsync(token, argument, options) {
-    return getCurrentInjectionContext(injectAllAsync, true).injectAllAsync(token, argument, options);
+    return await getCurrentInjectionContext(injectAllAsync, true).injectAllAsync(token, argument, options);
 }
 /**
  * Injects the resolve argument from the current resolution
@@ -84,9 +84,9 @@ export function runInInjectionContext(injectorOrContext, fn) {
             inject(token, argument, options) { return injectorOrContext.resolve(token, argument, options); },
             injectAll(token, argument, options) { return injectorOrContext.resolveAll(token, argument, options); },
             injectMany(...tokens) { return injectorOrContext.resolveMany(...tokens); },
-            async injectAsync(token, argument, options) { return injectorOrContext.resolveAsync(token, argument, options); },
-            async injectAllAsync(token, argument, options) { return injectorOrContext.resolveAllAsync(token, argument, options); },
-            async injectManyAsync(...tokens) { return injectorOrContext.resolveManyAsync(...tokens); },
+            async injectAsync(token, argument, options) { return await injectorOrContext.resolveAsync(token, argument, options); },
+            async injectAllAsync(token, argument, options) { return await injectorOrContext.resolveAllAsync(token, argument, options); },
+            async injectManyAsync(...tokens) { return await injectorOrContext.resolveManyAsync(...tokens); },
         }
         : injectorOrContext;
     const previousContext = setCurrentInjectionContext(context);

package/injector/injector.js

@@ -486,9 +486,9 @@ export class Injector {
             inject: (token, argument, options) => this.resolveInjection(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
             injectAll: (token, argument, options) => this.resolveInjectionAll(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
             injectMany: (...tokens) => this.resolveMany(...tokens),
-            injectAsync: async (token, argument, options) => this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-            injectAllAsync: async (token, argument, options) => this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
-            injectManyAsync: async (...tokens) => this.resolveManyAsync(...tokens),
+            injectAsync: async (token, argument, options) => await this.resolveInjectionAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectAllAsync: async (token, argument, options) => await this.resolveInjectionAllAsync(token, argument, options ?? {}, resolveContext, injectIndex++, chain),
+            injectManyAsync: async (...tokens) => await this.resolveManyAsync(...tokens),
         };
         return context;
     }

package/jsx/is-component-class.js

@@ -1,5 +1,5 @@
 import { Component } from 'preact';
-import { typeExtends } from '../utils/index.js';
+import { typeExtends } from '../utils/type/index.js';
 export function isComponentClass(template) {
     return typeExtends(template, Component);
 }

package/key-value-store/key-value.store.d.ts

@@ -6,18 +6,49 @@ export declare abstract class KeyValueStore<KV extends StringMap> implements Res
     readonly module: string;
     readonly [resolveArgumentType]: KeyValueStoreArgument;
     constructor(module: string);
-    /** Get value of key */
+    /**
+     * Gets the value of a key.
+     * @param key The key to get.
+     * @returns The value of the key or undefined if the key doesn't exist.
+     */
     abstract get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
-    /** Get value of key */
+    /**
+     * Gets the value of a key.
+     * @param key The key to get.
+     * @param defaultValue The default value to return if the key doesn't exist.
+     * @returns The value of the key or the default value if the key doesn't exist.
+     */
     abstract get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<KV[K] | D>;
-    /** Set key */
+    /**
+     * Sets the value of a key.
+     * @param key The key to set.
+     * @param value The value to set.
+     */
     abstract set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
-    /** Set multiple keys */
+    /**
+     * Get the value of a key or set it if it doesn't exist.
+     * @param key The key to get or set.
+     * @param value The value to set if the key doesn't exist.
+     */
+    abstract getOrSet<K extends keyof KV>(key: K, value: KV[K]): Promise<KV[K]>;
+    /**
+     * Sets multiple key-value pairs.
+     * @param keyValues The key-value pairs to set.
+     */
     abstract setMany(keyValues: Partial<KV>): Promise<void>;
-    /** Delete key */
+    /**
+     * Deletes a key.
+     * @param key The key to delete.
+     * @returns True if the key was deleted, false otherwise.
+     */
     abstract delete(key: keyof KV): Promise<boolean>;
-    /** Delete multiple keys */
+    /**
+     * Deletes multiple keys.
+     * @param keys The keys to delete.
+     */
     abstract deleteMany(keys: (keyof KV)[]): Promise<void>;
-    /** Delete all keys */
+    /**
+     * Clears all key-value pairs.
+     */
     abstract clear(): Promise<void>;
 }

package/key-value-store/key-value.store.js

@@ -1,6 +1,7 @@
+import { injectArgument } from '../injector/inject.js';
 import { resolveArgumentType } from '../injector/interfaces.js';
 export class KeyValueStore {
-    module;
+    module = injectArgument(this);
     constructor(module) {
         this.module = module;
     }

package/key-value-store/mongo/mongo-key-value.store.d.ts

@@ -7,6 +7,7 @@ export declare class MongoKeyValueStore<KV extends StringMap> extends KeyValueSt
     get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
     get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<D | KV[K]>;
     set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
+    getOrSet<K extends keyof KV>(key: K, value: KV[K]): Promise<KV[K]>;
     setMany(keyValues: Partial<KV>): Promise<void>;
     delete(key: keyof KV): Promise<boolean>;
     deleteMany(keys: (keyof KV)[]): Promise<void>;

package/key-value-store/mongo/mongo-key-value.store.js

@@ -32,24 +32,33 @@ let MongoKeyValueStore = class MongoKeyValueStore extends KeyValueStore {
         const timestamp = currentTimestamp();
         const update = {
             $set: { value, updated: timestamp },
-            $setOnInsert: { _id: getNewId() }
+            $setOnInsert: { _id: getNewId() },
         };
         await this.keyValueRepository.baseRepository.update({ module: this.module, key: key }, update, { upsert: true });
     }
+    async getOrSet(key, value) {
+        await this.keyValueRepository.baseRepository.insertIfNotExistsByFilter({
+            module: this.module,
+            key: key,
+            value,
+        }, { id: getNewId(), module: this.module, key: key, value, updated: currentTimestamp() });
+        const result = await this.get(key);
+        return result;
+    }
     async setMany(keyValues) {
         const timestamp = currentTimestamp();
         const bulk = this.keyValueRepository.baseRepository.bulk();
         for (const [key, value] of objectEntries(keyValues)) {
             const update = {
                 $set: { value, updated: timestamp },
-                $setOnInsert: { _id: getNewId() }
+                $setOnInsert: { _id: getNewId() },
             };
             bulk.update({ module: this.module, key }, update, { upsert: true });
         }
         await bulk.execute();
     }
     async delete(key) {
-        return this.keyValueRepository.deleteByFilter({ module: this.module, key: key });
+        return await this.keyValueRepository.deleteByFilter({ module: this.module, key: key });
     }
     async deleteMany(keys) {
         await this.keyValueRepository.deleteManyByFilter({ module: this.module, key: { $in: keys } });
@@ -65,8 +74,8 @@ MongoKeyValueStore = __decorate([
                 const provider = context.resolve(MongoKeyValueStoreProvider);
                 assertString(argument, 'Missing or invalid argument (KV-Store module)');
                 return provider.get(argument);
-            }
-        }
+            },
+        },
     }),
     __metadata("design:paramtypes", [MongoKeyValueRepository, String])
 ], MongoKeyValueStore);

package/key-value-store/postgres/drizzle/0000_shocking_slipstream.sql

@@ -0,0 +1,12 @@
+CREATE TABLE "key_value_store"."key_value" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"module" text NOT NULL,
+	"key" text NOT NULL,
+	"value" jsonb NOT NULL,
+	"revision" integer NOT NULL,
+	"revision_timestamp" timestamp with time zone NOT NULL,
+	"create_timestamp" timestamp with time zone NOT NULL,
+	"delete_timestamp" timestamp with time zone,
+	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
+	CONSTRAINT "key_value_module_key_unique" UNIQUE("module","key")
+);

package/key-value-store/postgres/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,97 @@
+{
+  "id": "9aad7b6a-d248-42fa-90ca-a7119748e2e4",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "key_value_store.key_value": {
+      "name": "key_value",
+      "schema": "key_value_store",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "module": {
+          "name": "module",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revision_timestamp": {
+          "name": "revision_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "create_timestamp": {
+          "name": "create_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "delete_timestamp": {
+          "name": "delete_timestamp",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "attributes": {
+          "name": "attributes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "key_value_module_key_unique": {
+          "name": "key_value_module_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "module",
+            "key"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/key-value-store/postgres/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1749405256053,
+      "tag": "0000_shocking_slipstream",
+      "breakpoints": true
+    }
+  ]
+}

package/key-value-store/postgres/drizzle.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;

package/key-value-store/postgres/drizzle.config.js

@@ -0,0 +1,11 @@
+import { relative, resolve } from 'node:path';
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    dialect: 'postgresql',
+    out: relative('./', resolve(__dirname, './drizzle/').replace('dist', 'source')),
+    schema: resolve(__dirname, './models/schemas.js'),
+    migrations: {
+        schema: 'key_value_store',
+        table: '_migrations',
+    },
+});

package/key-value-store/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export * from './key-value-store.service.js';
+export * from './module.js';

package/key-value-store/postgres/index.js

@@ -0,0 +1,2 @@
+export * from './key-value-store.service.js';
+export * from './module.js';

package/key-value-store/postgres/key-value-store.service.d.ts

@@ -0,0 +1,17 @@
+import { type resolveArgumentType } from '../../injector/index.js';
+import { Transactional } from '../../orm/server/index.js';
+import type { Record } from '../../types.js';
+import { KeyValueStore, type KeyValueStoreArgument } from '../key-value.store.js';
+export declare class PostgresKeyValueStore<KV extends Record<string, unknown>> extends Transactional implements KeyValueStore<KV> {
+    #private;
+    readonly module: string;
+    readonly [resolveArgumentType]: KeyValueStoreArgument;
+    get<K extends keyof KV>(key: K): Promise<KV[K] | undefined>;
+    get<K extends keyof KV, D>(key: K, defaultValue: D): Promise<KV[K] | D>;
+    set<K extends keyof KV>(key: K, value: KV[K]): Promise<void>;
+    getOrSet<K extends keyof KV>(key: K, value: KV[K]): Promise<KV[K]>;
+    setMany(keyValues: Partial<KV>): Promise<void>;
+    delete(key: keyof KV): Promise<boolean>;
+    deleteMany(keys: (keyof KV)[]): Promise<void>;
+    clear(): Promise<void>;
+}