@daiso-tech/core 0.6.0 → 0.7.0

package/dist/types/serializer/implementations/mongodb-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/mongodb-serializer/mongodb-serializer";

package/dist/types/serializer/implementations/mongodb-serializer/mongodb-serializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+/**
+ * @internal
+ */
+export declare class MongodbSerializer implements ISerializer<string | number> {
+    private readonly serializer;
+    constructor(serializer: ISerializer<string>);
+    serialize<TValue>(value: TValue): Promise<string | number>;
+    deserialize<TValue>(value: string | number): Promise<TValue>;
+}

package/dist/types/serializer/implementations/redis-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/redis-serializer/redis-serializer";

package/dist/types/serializer/implementations/redis-serializer/redis-serializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+/**
+ * @internal
+ */
+export declare class RedisSerializer implements ISerializer<string> {
+    private readonly serializer;
+    constructor(serializer: ISerializer<string>);
+    serialize<TValue>(value: TValue): Promise<string>;
+    deserialize<TValue>(value: string): Promise<TValue>;
+}

package/dist/types/serializer/implementations/sql-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/sql-serializer/sql-serializer";

package/dist/types/serializer/implementations/sql-serializer/sql-serializer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+/**
+ * @internal
+ */
+export declare class SqlSerializer implements ISerializer<string> {
+    private readonly serializer;
+    constructor(serializer: ISerializer<string>);
+    serialize<TValue>(value: TValue): Promise<string>;
+    deserialize<TValue>(value: string): Promise<TValue>;
+}

package/dist/types/serializer/implementations/super-json-serializer/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../serializer/implementations/super-json-serializer/super-json-serializer";

package/dist/types/serializer/implementations/super-json-serializer/super-json-serializer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @module Serializer
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import type { SuperJSON } from "superjson";
+/**
+ * @group Adapters
+ */
+export type SuperJsonSerializerSettings = {
+    dedupe?: boolean;
+    registerClass?: (registerClass: SuperJSON["registerClass"]) => void;
+    registerSymbol?: (registerClass: SuperJSON["registerSymbol"]) => void;
+    registerCustom?: (registerClass: SuperJSON["registerCustom"]) => void;
+};
+/**
+ * @group Adapters
+ */
+export declare class SuperJsonSerializer implements ISerializer<string> {
+    private superJson;
+    private dedupe;
+    private registerClass;
+    private registerSymbol;
+    private registerCustom;
+    constructor({ dedupe, registerClass, registerSymbol, registerCustom, }?: SuperJsonSerializerSettings);
+    private static registerBuffer;
+    private static registerUint8Array;
+    private static registerInt8Array;
+    private static registerUint16Array;
+    private static registerInt16Array;
+    private static registerUint32Array;
+    private static registerInt32Array;
+    private static registerFloat32Array;
+    private static registerFloat64Array;
+    private init;
+    serialize<TValue>(value: TValue): Promise<string>;
+    deserialize<TValue>(value: string): Promise<TValue>;
+}

package/dist/types/storage/contracts/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../../storage/contracts/_shared";
+export * from "../../storage/contracts/storage.contract";
+export * from "../../storage/contracts/storage-adapter.contract";

package/dist/types/storage/contracts/storage-adapter.contract.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @module Storage
+ */
+/**
+ * @throws {StorageError} {@link StorageError}
+ * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+ * @throws {TypeStorageError} {@link TypeStorageError}
+ * @group Contracts
+ */
+export type IStorageAdapter<TType> = {
+    /**
+     * Returns the value for the keys that are found otherwise null will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
+    /**
+     * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Will increment the existing key with value if found otherwise nonthing occurs. Returns true if key exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * @throws {TypeStorageError} {@link TypeStorageError}
+     */
+    increment(key: string, value: number): PromiseLike<boolean>;
+    /**
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    clear(prefix: string): PromiseLike<void>;
+};

package/dist/types/storage/contracts/storage.contract.d.ts

@@ -0,0 +1,151 @@
+/**
+ * @module Storage
+ */
+import { type AnyFunction, type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
+export type StorageValue<T> = Exclude<T, AnyFunction | undefined | null>;
+/**
+ * @throws {StorageError} {@link StorageError}
+ * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+ * @throws {TypeStorageError} {@link TypeStorageError}
+ * @group Contracts
+ */
+export type IStorage<TType = unknown> = {
+    /**
+     * Return a new instance of <i>IStorage</i> prefixed with given <i>name</i>
+     */
+    namespace(name: string): IStorage<TType>;
+    /**
+     * Returns true when key is found otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    exists(key: string): PromiseLike<boolean>;
+    /**
+     * Returns true for the keys that are found otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Returns true when key is not found otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    missing(key: string): PromiseLike<boolean>;
+    /**
+     * Returns true for the keys that are not found otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Returns the value when key is found otherwise null will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    get(key: string): PromiseLike<TType | null>;
+    /**
+     * Returns the value for the keys that are found otherwise null will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
+    /**
+     * Returns the value when key is found otherwise defaultValue will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    getOr(key: string, defaultValue: AsyncLazyable<TType>): PromiseLike<TType>;
+    /**
+     * Returns the value for the keys that are found otherwise defaultValue will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): PromiseLike<Record<TKeys, TType>>;
+    /**
+     * Returns the value when key is found otherwise an error will be thrown.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
+     */
+    getOrFail(key: string): PromiseLike<TType>;
+    /**
+     * Adds a key when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    add(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    /**
+     * Adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Updates a keys that exists. Returns true when key otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    update(key: string, value: TType): PromiseLike<boolean>;
+    /**
+     * Updates the keys that exists. Returns true for the keys that exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * If the key is found it will replaced. If the key is not found it will just be added. True is returned if the key is found otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    put(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    /**
+     * Replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * Removes the key when found. Returns true if the key is found otherwise false is returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    remove(key: string): PromiseLike<boolean>;
+    /**
+     * Removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    /**
+     * If the key is found the value be returned and key will be removed otherwise null will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    getAndRemove(key: string): PromiseLike<TType | null>;
+    /**
+     * If the key is found the value be returned otherwise valueToAdd will be added and returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): PromiseLike<TType>;
+    /**
+     * Will increment the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * @throws {TypeStorageError} {@link TypeStorageError}
+     */
+    increment(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    /**
+     * Will decrement the existing key with value if found otherwise nonthing will occur. Returns true if key exists otherwise false will be returned.
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     * @throws {TypeStorageError} {@link TypeStorageError}
+     */
+    decrement(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    /**
+     * @throws {StorageError} {@link StorageError}
+     * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
+     */
+    clear(): PromiseLike<void>;
+};

package/dist/types/storage/implementations/_module.d.ts

@@ -0,0 +1,6 @@
+export * from "../../storage/implementations/storage/_module";
+export * from "../../storage/implementations/_shared/test-utilities/_module";
+export * from "../../storage/implementations/memory-storage-adapter/_module";
+export * from "../../storage/implementations/mongodb-storage-adapter/_module";
+export * from "../../storage/implementations/redis-storage-adapter/_module";
+export * from "../../storage/implementations/sqlite/_module";

package/dist/types/storage/implementations/_shared/test-utilities/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/_shared/test-utilities/storage-adapter.test-suite";

package/dist/types/storage/implementations/_shared/test-utilities/storage-adapter-api.test-suite.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module Storage
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type Promisable } from "../../../../_shared/types";
+/**
+ * @internal
+ */
+export type StorageApiTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @internal
+ */
+export declare function storageAdapterApiTestSuite(settings: StorageApiTestSuiteSettings): void;

package/dist/types/storage/implementations/_shared/test-utilities/storage-adapter-value.test-suite.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module Storage
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type Promisable } from "../../../../_shared/types";
+/**
+ * @internal
+ */
+export type StorageValueTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @internal
+ */
+export declare function storageAdapterValueTestSuite(settings: StorageValueTestSuiteSettings): void;

package/dist/types/storage/implementations/_shared/test-utilities/storage-adapter.test-suite.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @module Storage
+ */
+import { type TestAPI, type SuiteAPI, type ExpectStatic, type beforeEach } from "vitest";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type Promisable } from "../../../../_shared/types";
+/**
+ * @group Utilities
+ */
+export type StorageAdapterTestSuiteSettings = {
+    expect: ExpectStatic;
+    test: TestAPI;
+    describe: SuiteAPI;
+    beforeEach: typeof beforeEach;
+    createAdapter: () => Promisable<IStorageAdapter<unknown>>;
+};
+/**
+ * @group Utilities
+ */
+export declare function storageTestSuite(settings: StorageAdapterTestSuiteSettings): void;

package/dist/types/storage/implementations/memory-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../storage/implementations/memory-storage-adapter/memory-storage-adapter";

package/dist/types/storage/implementations/memory-storage-adapter/memory-storage-adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../storage/contracts/storage-adapter.contract";
+/**
+ * @group Adapters
+ */
+export declare class MemoryStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly map;
+    constructor(map?: Map<string, TType>);
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/implementations/mongodb-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export { MongodbStorageAdapter, type MongodbStorageAdapterSettings, } from "../../../storage/implementations/mongodb-storage-adapter/mongodb-storage-adapter";

package/dist/types/storage/implementations/mongodb-storage-adapter/mongodb-storage-adapter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import { type IInitizable } from "../../../_shared/types";
+import { type IStorageAdapter } from "../../../storage/contracts/_module";
+import { type Collection, ObjectId } from "mongodb";
+/**
+ * @group Adapters
+ */
+export type MongodbStorageDocument = {
+    _id: ObjectId;
+    key: string;
+    value: number | string;
+};
+/**
+ * @group Adapters
+ */
+export type MongodbStorageAdapterSettings = {
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class MongodbStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly collection;
+    private static isMongodbIncrementError;
+    private static isMongoDuplicateError;
+    private serializer;
+    constructor(collection: Collection<MongodbStorageDocument>, { serializer, }?: MongodbStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private updateOne;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private putOne;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    private removeOne;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/implementations/redis-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../storage/implementations/redis-storage-adapter/redis-storage-adapter";

package/dist/types/storage/implementations/redis-storage-adapter/redis-storage-adapter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module Storage
+ */
+import { type ISerializer } from "../../../serializer/contracts/_module";
+import { type IStorageAdapter } from "../../../storage/contracts/_module";
+import type Redis from "ioredis";
+import { type Result } from "ioredis";
+declare module "ioredis" {
+    interface RedisCommander<Context> {
+        daiso_storage_increment(key: string, number: string): Result<number, Context>;
+        daiso_storage_put(key: string, value: string): Result<string, Context>;
+        daiso_storage_getOrAdd(key: string, valueToAdd: string): Result<string, Context>;
+    }
+}
+/**
+ * @group Adapters
+ */
+export type RedisStorageAdapterSettings = {
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class RedisStorageAdapter<TType> implements IStorageAdapter<TType> {
+    private readonly client;
+    private serializer;
+    constructor(client: Redis, { serializer, }?: RedisStorageAdapterSettings);
+    private initIncrementCommand;
+    private initPutCommand;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/implementations/sqlite/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../storage/implementations/sqlite/sqlite-storage-adapter/_module";
+export * from "../../../storage/implementations/sqlite/libsql-storage-adapter/_module";

package/dist/types/storage/implementations/sqlite/_shared/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/sqlite/_shared/base-sqlite-storage-adapter";

package/dist/types/storage/implementations/sqlite/_shared/base-sqlite-storage-adapter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module Storage
+ */
+import { type IStorageAdapter } from "../../../../storage/contracts/storage-adapter.contract";
+import { type Generated, type Kysely } from "kysely";
+import { type ISerializer } from "../../../../serializer/contracts/_module";
+import { type IInitizable } from "../../../../_shared/types";
+/**
+ * @internal
+ */
+type BaseSqliteStorageTable = {
+    key: string;
+    value: string;
+    hasBeenUpdated: Generated<1 | 0>;
+};
+/**
+ * @internal
+ */
+type BaseSqliteTables = {
+    storage: BaseSqliteStorageTable;
+};
+/**
+ * @internal
+ */
+export declare class BaseSqliteStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly db;
+    private readonly serializer;
+    constructor(db: Kysely<BaseSqliteTables>, serializer: ISerializer<string>);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}
+export {};

package/dist/types/storage/implementations/sqlite/libsql-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/sqlite/libsql-storage-adapter/libsql-storage-adapter";

package/dist/types/storage/implementations/sqlite/libsql-storage-adapter/libsql-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type IInitizable } from "../../../../_shared/types";
+import type { Client } from "@libsql/client";
+/**
+ * @group Adapters
+ */
+export type LibsqlStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class LibsqlStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly storageAdapter;
+    constructor(client: Client, { tableName, serializer, }?: LibsqlStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/implementations/sqlite/sqlite-storage-adapter/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../../storage/implementations/sqlite/sqlite-storage-adapter/sqlite-storage-adapter";

package/dist/types/storage/implementations/sqlite/sqlite-storage-adapter/sqlite-storage-adapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Storage
+ */
+import type { ISerializer } from "../../../../serializer/contracts/_module";
+import { type IStorageAdapter } from "../../../../storage/contracts/_module";
+import { type Database } from "better-sqlite3";
+import { type IInitizable } from "../../../../_shared/types";
+/**
+ * @group Adapters
+ */
+export type SqliteStorageAdapterSettings = {
+    tableName?: string;
+    serializer?: ISerializer<string>;
+};
+/**
+ * @group Adapters
+ */
+export declare class SqliteStorageAdapter<TType> implements IStorageAdapter<TType>, IInitizable {
+    private readonly storageAdapter;
+    constructor(database: Database, { tableName, serializer, }?: SqliteStorageAdapterSettings);
+    init(): Promise<void>;
+    existsMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    getMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, TType | null>>;
+    addMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    updateMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, TType>): Promise<Record<TKeys, boolean>>;
+    removeMany<TKeys extends string>(keys: TKeys[]): Promise<Record<TKeys, boolean>>;
+    increment(key: string, value: number): Promise<boolean>;
+    clear(prefix: string): Promise<void>;
+}

package/dist/types/storage/implementations/storage/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../storage/implementations/storage/storage";