@nice-code/util 0.8.0 → 0.9.0

package/build/types/crypto/crypto.schema.d.ts

@@ -1,92 +0,0 @@
-import * as v from "valibot";
-export declare enum ECryptoKeyAlgo {
-    ed25519 = "ed25519",
-    x25519 = "x25519"
-}
-export declare enum ECryptoKeyFormat {
-    raw_base64 = "raw_base64",
-    jwk = "jwk"
-}
-export declare const vSerializedCryptoKeyDataEd25519_Raw: v.SchemaWithPipe<readonly [v.CustomSchema<`ed25519::raw_base64::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-export declare const vSerializedCryptoKeyDataEd25519_Jwk: v.SchemaWithPipe<readonly [v.CustomSchema<`ed25519::jwk::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-export type TSerializedCryptoKeyData_Ed25519_Raw = v.InferInput<typeof vSerializedCryptoKeyDataEd25519_Raw>;
-export type TSerializedCryptoKeyData_Ed25519_Raw_Transformed = {
-    formattedString: `${ECryptoKeyAlgo.ed25519}::${ECryptoKeyFormat.raw_base64}::${string}`;
-    type: ECryptoKeyAlgo.ed25519;
-    format: ECryptoKeyFormat.raw_base64;
-    data: string;
-};
-export type TSerializedCryptoKeyData_Ed25519_Jwk = v.InferInput<typeof vSerializedCryptoKeyDataEd25519_Jwk>;
-export type TSerializedCryptoKeyData_Ed25519_Jwk_Transformed = {
-    formattedString: `${ECryptoKeyAlgo.ed25519}::${ECryptoKeyFormat.jwk}::${string}`;
-    type: ECryptoKeyAlgo.ed25519;
-    format: ECryptoKeyFormat.jwk;
-    data: JsonWebKey;
-};
-export declare const vSerializedCryptoKeyDataX25519_Raw: v.SchemaWithPipe<readonly [v.CustomSchema<`x25519::raw_base64::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-export declare const vSerializedCryptoKeyDataX25519_Jwk: v.SchemaWithPipe<readonly [v.CustomSchema<`x25519::jwk::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-export declare const vCryptoKeyPairDataX25519: v.ObjectSchema<{
-    readonly publicKey: v.SchemaWithPipe<readonly [v.CustomSchema<`x25519::raw_base64::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-    readonly privateKey: v.SchemaWithPipe<readonly [v.CustomSchema<`x25519::jwk::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-}, undefined>;
-export type TSerializedCryptoKeyPairDataX25519 = v.InferInput<typeof vCryptoKeyPairDataX25519>;
-export declare const vCryptoKeyPairDataEd25519: v.ObjectSchema<{
-    readonly publicKey: v.SchemaWithPipe<readonly [v.CustomSchema<`ed25519::raw_base64::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-    readonly privateKey: v.SchemaWithPipe<readonly [v.CustomSchema<`ed25519::jwk::${string}`, v.ErrorMessage<v.CustomIssue> | undefined>]>;
-}, undefined>;
-export type TSerializedCryptoKeyPairDataEd25519 = v.InferInput<typeof vCryptoKeyPairDataEd25519>;
-export type TSerializedCryptoKeyData_X25519_Raw = v.InferInput<typeof vSerializedCryptoKeyDataX25519_Raw>;
-export type TSerializedCryptoKeyData_X25519_Raw_Transformed = {
-    formattedString: `${ECryptoKeyAlgo.x25519}::${ECryptoKeyFormat.raw_base64}::${string}`;
-    type: ECryptoKeyAlgo.x25519;
-    format: ECryptoKeyFormat.raw_base64;
-    data: string;
-};
-export type TSerializedCryptoKeyData_X25519_Jwk = v.InferInput<typeof vSerializedCryptoKeyDataX25519_Jwk>;
-export type TSerializedCryptoKeyData_X25519_Jwk_Transformed = {
-    formattedString: `${ECryptoKeyAlgo.x25519}::${ECryptoKeyFormat.jwk}::${string}`;
-    type: ECryptoKeyAlgo.x25519;
-    format: ECryptoKeyFormat.jwk;
-    data: JsonWebKey;
-};
-export declare const vVerifyChallengeWithSignature_Input: v.ObjectSchema<{
-    readonly challenge: v.StringSchema<undefined>;
-    readonly signatureBase64: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
-}, undefined>;
-export declare const vVerifyChallengeWithSignature_WithThrow_Input: v.IntersectSchema<[v.ObjectSchema<{
-    readonly challenge: v.StringSchema<undefined>;
-    readonly signatureBase64: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
-}, undefined>, v.ObjectSchema<{
-    readonly throwOnInvalid: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
-}, undefined>], undefined>;
-export type TVerifyChallengeWithSignature_Input = v.InferInput<typeof vVerifyChallengeWithSignature_Input>;
-export type TVerifyChallengeWithSignature_WithThrow_Input = v.InferInput<typeof vVerifyChallengeWithSignature_WithThrow_Input>;
-export declare const vEncryptedAesGcmPayload: v.ObjectSchema<{
-    readonly nonce: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
-    readonly ciphertext: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
-}, undefined>;
-export type TEncryptedAesGcmPayload = v.InferInput<typeof vEncryptedAesGcmPayload>;
-export type TEncryptedAesGcmPayload_Transformed = v.InferOutput<typeof vEncryptedAesGcmPayload>;
-/**
- * Raw-bytes counterpart of {@link TEncryptedAesGcmPayload} — keeps `nonce`/`ciphertext` as binary
- * instead of base64 strings. For binary channels (e.g. msgpack WebSocket frames) this avoids the
- * ~33% base64 inflation the text payload incurs.
- */
-export type TEncryptedAesGcmBytes = {
-    nonce: Uint8Array;
-    ciphertext: Uint8Array;
-};
-interface ISerializedKeyData<T, P> {
-    transformed: T;
-    prefixed: P;
-}
-export interface ISerializedKeyData_Ed25519_Raw extends ISerializedKeyData<TSerializedCryptoKeyData_Ed25519_Raw_Transformed, TSerializedCryptoKeyData_Ed25519_Raw> {
-}
-export interface ISerializedKeyData_Ed25519_Jwk extends ISerializedKeyData<TSerializedCryptoKeyData_Ed25519_Jwk_Transformed, TSerializedCryptoKeyData_Ed25519_Jwk> {
-}
-export interface ISerializedKeyData_X25519_Raw extends ISerializedKeyData<TSerializedCryptoKeyData_X25519_Raw_Transformed, TSerializedCryptoKeyData_X25519_Raw> {
-}
-export interface ISerializedKeyData_X25519_Jwk extends ISerializedKeyData<TSerializedCryptoKeyData_X25519_Jwk_Transformed, TSerializedCryptoKeyData_X25519_Jwk> {
-}
-export type TSerializedKeyData = ISerializedKeyData_Ed25519_Raw | ISerializedKeyData_Ed25519_Jwk | ISerializedKeyData_X25519_Raw | ISerializedKeyData_X25519_Jwk;
-export {};

package/build/types/crypto/ed25519/generateEd25519KeyPair.d.ts

@@ -1 +0,0 @@
-export declare const generateEd25519KeyPair: () => Promise<CryptoKeyPair>;

package/build/types/crypto/ed25519/importEd25519Key.d.ts

@@ -1,35 +0,0 @@
-import { type TSerializedCryptoKeyData_Ed25519_Jwk_Transformed, type TSerializedCryptoKeyData_Ed25519_Raw_Transformed } from "../crypto.schema";
-export declare const importEd25519Key: {
-    private: {
-        fromFormattedString: {
-            readonly extractable: (input: `ed25519::jwk::${string}`) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: `ed25519::jwk::${string}`) => Promise<CryptoKey>;
-        };
-        fromSerializedObject: {
-            readonly extractable: (input: TSerializedCryptoKeyData_Ed25519_Jwk_Transformed) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: TSerializedCryptoKeyData_Ed25519_Jwk_Transformed) => Promise<CryptoKey>;
-        };
-        fromJwk: {
-            readonly extractable: (input: JsonWebKey) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: JsonWebKey) => Promise<CryptoKey>;
-        };
-    };
-    public: {
-        fromBase64: {
-            readonly extractable: (input: string) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: string) => Promise<CryptoKey>;
-        };
-        fromFormattedString: {
-            readonly extractable: (input: `ed25519::raw_base64::${string}` | `ed25519::jwk::${string}`) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: `ed25519::raw_base64::${string}` | `ed25519::jwk::${string}`) => Promise<CryptoKey>;
-        };
-        fromSerializedObject: {
-            readonly extractable: (input: TSerializedCryptoKeyData_Ed25519_Raw_Transformed | TSerializedCryptoKeyData_Ed25519_Jwk_Transformed) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: TSerializedCryptoKeyData_Ed25519_Raw_Transformed | TSerializedCryptoKeyData_Ed25519_Jwk_Transformed) => Promise<CryptoKey>;
-        };
-        fromJwk: {
-            readonly extractable: (input: JsonWebKey) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: JsonWebKey) => Promise<CryptoKey>;
-        };
-    };
-};

package/build/types/crypto/ed25519/serializeEd25519Key_Jwk.d.ts

@@ -1,2 +0,0 @@
-import { type ISerializedKeyData_Ed25519_Jwk } from "../crypto.schema";
-export declare const serializeEd25519Key_Jwk: (key: CryptoKey) => Promise<ISerializedKeyData_Ed25519_Jwk>;

package/build/types/crypto/ed25519/serializeEd25519Key_Raw.d.ts

@@ -1,2 +0,0 @@
-import { type ISerializedKeyData_Ed25519_Raw } from "../crypto.schema";
-export declare const serializeEd25519Key_Raw: (publicKey: CryptoKey) => Promise<ISerializedKeyData_Ed25519_Raw>;

package/build/types/crypto/ed25519/signCombinedTextDataWithKeyEd25519.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_COMBINED_TEXT_DATA_SEPARATOR = "::";
-export declare const signCombinedTextDataWithKeyEd25519: (data: string[], cryptoKey: CryptoKey, separator?: string) => Promise<Uint8Array>;

package/build/types/crypto/ed25519/signTextDataWithKeyEd25519.d.ts

@@ -1 +0,0 @@
-export declare const signTextDataWithKeyEd25519: (data: string, cryptoKey: CryptoKey) => Promise<Uint8Array>;

package/build/types/crypto/ed25519/verifyWithKeyEd25519.d.ts

@@ -1,5 +0,0 @@
-export declare const verifyWithKeyEd25519: ({ challenge, signatureBase64, publicKey, }: {
-    challenge: string;
-    signatureBase64: string;
-    publicKey: CryptoKey;
-}) => Promise<boolean>;

package/build/types/crypto/index.d.ts

@@ -1,21 +0,0 @@
-export * from "./aes_gcm/createAesGcmKeyFromX25519Keys";
-export * from "./aes_gcm/decryptBytesWithAesGcmKey";
-export * from "./aes_gcm/decryptTextDataWithAesGcmKey";
-export * from "./aes_gcm/encryptBytesWithAesGcmKey";
-export * from "./aes_gcm/encryptTextDataWithAesGcmKey";
-export * from "./client_key_link/buildVerifyKeyBoundInfoString";
-export * from "./client_key_link/ClientCryptoKeyLink";
-export * from "./crypto.converters";
-export * from "./crypto.schema";
-export * from "./ed25519/generateEd25519KeyPair";
-export * from "./ed25519/importEd25519Key";
-export * from "./ed25519/serializeEd25519Key_Jwk";
-export * from "./ed25519/serializeEd25519Key_Raw";
-export * from "./ed25519/signCombinedTextDataWithKeyEd25519";
-export * from "./ed25519/signTextDataWithKeyEd25519";
-export * from "./ed25519/verifyWithKeyEd25519";
-export * from "./x25519/createSharedBitsFromX25519";
-export * from "./x25519/generateX25519KeyPair";
-export * from "./x25519/importX25519Key";
-export * from "./x25519/serializeX25519Key_Jwk";
-export * from "./x25519/serializeX25519Key_Raw";

package/build/types/crypto/x25519/createSharedBitsFromX25519.d.ts

@@ -1,4 +0,0 @@
-export declare const createSharedBitsFromX25519: ({ privateKey, publicKey, }: {
-    privateKey: CryptoKey;
-    publicKey: CryptoKey;
-}) => Promise<Uint8Array>;

package/build/types/crypto/x25519/generateX25519KeyPair.d.ts

@@ -1 +0,0 @@
-export declare const generateX25519KeyPair: () => Promise<CryptoKeyPair>;

package/build/types/crypto/x25519/importX25519Key.d.ts

@@ -1,35 +0,0 @@
-import { type TSerializedCryptoKeyData_X25519_Jwk_Transformed, type TSerializedCryptoKeyData_X25519_Raw_Transformed } from "../crypto.schema";
-export declare const importX25519Key: {
-    private: {
-        fromFormattedString: {
-            readonly extractable: (input: `x25519::jwk::${string}`) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: `x25519::jwk::${string}`) => Promise<CryptoKey>;
-        };
-        fromSerializedObject: {
-            readonly extractable: (input: TSerializedCryptoKeyData_X25519_Jwk_Transformed) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: TSerializedCryptoKeyData_X25519_Jwk_Transformed) => Promise<CryptoKey>;
-        };
-        fromJwk: {
-            readonly extractable: (input: JsonWebKey) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: JsonWebKey) => Promise<CryptoKey>;
-        };
-    };
-    public: {
-        fromBase64: {
-            readonly extractable: (input: string) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: string) => Promise<CryptoKey>;
-        };
-        fromFormattedString: {
-            readonly extractable: (input: `x25519::raw_base64::${string}` | `x25519::jwk::${string}`) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: `x25519::raw_base64::${string}` | `x25519::jwk::${string}`) => Promise<CryptoKey>;
-        };
-        fromSerializedObject: {
-            readonly extractable: (input: TSerializedCryptoKeyData_X25519_Raw_Transformed | TSerializedCryptoKeyData_X25519_Jwk_Transformed) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: TSerializedCryptoKeyData_X25519_Raw_Transformed | TSerializedCryptoKeyData_X25519_Jwk_Transformed) => Promise<CryptoKey>;
-        };
-        fromJwk: {
-            readonly extractable: (input: JsonWebKey) => Promise<CryptoKey>;
-            readonly nonExtractable: (input: JsonWebKey) => Promise<CryptoKey>;
-        };
-    };
-};

package/build/types/crypto/x25519/serializeX25519Key_Jwk.d.ts

@@ -1,2 +0,0 @@
-import { type ISerializedKeyData_X25519_Jwk } from "../crypto.schema";
-export declare const serializeX25519Key_Jwk: (key: CryptoKey) => Promise<ISerializedKeyData_X25519_Jwk>;

package/build/types/crypto/x25519/serializeX25519Key_Raw.d.ts

@@ -1,2 +0,0 @@
-import { type ISerializedKeyData_X25519_Raw } from "../crypto.schema";
-export declare const serializeX25519Key_Raw: (key: CryptoKey) => Promise<ISerializedKeyData_X25519_Raw>;

package/build/types/data_type/index.d.ts

@@ -1 +0,0 @@
-export * from "./string/nullEmpty";

package/build/types/data_type/string/nullEmpty.d.ts

@@ -1,3 +0,0 @@
-export declare const notNullEmpty: (str: string | null | undefined) => str is string;
-export declare const nullEmpty: (str: string | null | undefined) => str is null | undefined | "";
-export declare const firstNotNullEmpty: (...strItems: (string | null | undefined)[]) => string | undefined;

package/build/types/index.d.ts

@@ -1,10 +0,0 @@
-export type { TTypeAndId } from "./core/core_valibot_schemas";
-export * from "./crypto";
-export * from "./storage_adapter/StorageAdapter";
-export * from "./storage_adapter/specific/browser/browser_storage";
-export * from "./storage_adapter/specific/cloudflare/durable_object/durable_object_storage";
-export * from "./storage_adapter/specific/cloudflare/kv/kv_storage";
-export * from "./storage_adapter/specific/memory/memory_storage";
-export * from "./storage_adapter/storage_adapter.types";
-export * from "./storage_adapter/typed_storage/createTypedStorage";
-export * from "./typescript/special_typescript_types";

package/build/types/storage_adapter/StorageAdapter.d.ts

@@ -1,23 +0,0 @@
-import { type IStorageKeyGetterAndSetter, type TStorageAdapterMethods } from "./storage_adapter.types";
-export interface IStorageAdapterConstructor {
-    methods: TStorageAdapterMethods;
-    trackKeysForClearing?: boolean;
-    keyPrefix?: string;
-}
-export declare class StorageAdapter {
-    private implementation;
-    readonly keyPrefix: string;
-    private readonly adapterStorage?;
-    constructor({ methods, keyPrefix, trackKeysForClearing: trackKeys }: IStorageAdapterConstructor);
-    private getPrefixedKey;
-    private trackUsedKey;
-    private untrackUsedKey;
-    clearAll(): Promise<void>;
-    removeItem(rawKey: string): Promise<void>;
-    setJson(rawKey: string, value: any): Promise<void>;
-    getJson<T>(rawKey: string): Promise<T | undefined>;
-    getJsonOrDef<T>(rawKey: string, defVal: T): Promise<T>;
-    updateJson<T>(rawKey: string, updater: (currentVal: T | undefined) => T): Promise<T>;
-    updateJsonOrDef<T>(rawKey: string, defVal: T, updater: (currentVal: T) => T): Promise<T>;
-    createJsonGetterSetter<T>(rawKey: string): IStorageKeyGetterAndSetter<T>;
-}

package/build/types/storage_adapter/specific/browser/browser_storage.d.ts

@@ -1,26 +0,0 @@
-import { type IStorageAdapterConstructor, StorageAdapter } from "../../StorageAdapter";
-import { type IStorageAdapterMethods_String } from "../../storage_adapter.types";
-import { type ITypedStorage } from "../../typed_storage/createTypedStorage";
-/**
- *
- * Web Storage [LOCAL STORAGE]
- *
- */
-type TCreateWebLocalStorageOptions = Omit<IStorageAdapterConstructor, "methods"> & {
-    localStorage: typeof localStorage;
-};
-export declare function createWebLocalStorageMethods(_localStorage: typeof localStorage): IStorageAdapterMethods_String;
-export declare const createWebLocalStorageAdapter: ({ localStorage: _localStorage, ...options }: TCreateWebLocalStorageOptions) => StorageAdapter;
-export declare function createTypedWebLocalStorage<T extends Record<string, any>>(options: TCreateWebLocalStorageOptions): ITypedStorage<T>;
-/**
- *
- * Web Storage [SESSION STORAGE]
- *
- */
-type TCreateWebSessionStorageOptions = Omit<IStorageAdapterConstructor, "methods"> & {
-    sessionStorage: typeof sessionStorage;
-};
-export declare function createWebSessionStorageMethods(_sessionStorage: typeof sessionStorage): IStorageAdapterMethods_String;
-export declare const createWebSessionStorageAdapter: ({ sessionStorage: _sessionStorage, ...options }: TCreateWebSessionStorageOptions) => StorageAdapter;
-export declare function createTypedWebSessionStorage<T extends Record<string, any>>(options: TCreateWebSessionStorageOptions): ITypedStorage<T>;
-export {};

package/build/types/storage_adapter/specific/cloudflare/durable_object/durable_object_storage.d.ts

@@ -1,14 +0,0 @@
-import { type IStorageAdapterConstructor, StorageAdapter } from "../../../StorageAdapter";
-import { type IStorageAdapterMethods_Json } from "../../../storage_adapter.types";
-import { type ITypedStorage } from "../../../typed_storage/createTypedStorage";
-import type { IDurableObjectStorage } from "./durable_object_storage.types";
-export declare function createDurableObjectStorageMethods(durableObjectStorage: IDurableObjectStorage): IStorageAdapterMethods_Json;
-export type TCreateDurableObjectStorageOptions = Omit<IStorageAdapterConstructor, "methods"> & {
-    durableObjectStorage: IDurableObjectStorage;
-};
-/**
- * Wraps a Durable Object's storage in the generic StorageAdapter interface, e.g. for handing to a
- * ClientCryptoKeyLink so it can persist its keys inside the DO's own storage.
- */
-export declare const createDurableObjectStorageAdapter: ({ durableObjectStorage, ...options }: TCreateDurableObjectStorageOptions) => StorageAdapter;
-export declare function createDurableObjectTypedStorage<T extends Record<string, any>>(options: TCreateDurableObjectStorageOptions): ITypedStorage<T>;

package/build/types/storage_adapter/specific/cloudflare/durable_object/durable_object_storage.types.d.ts

@@ -1,18 +0,0 @@
-interface DurableObjectGetOptions {
-    allowConcurrency?: boolean;
-    noCache?: boolean;
-}
-interface DurableObjectPutOptions {
-    allowConcurrency?: boolean;
-    allowUnconfirmed?: boolean;
-    noCache?: boolean;
-}
-export interface IDurableObjectStorage {
-    get<T = unknown>(key: string, options?: DurableObjectGetOptions): Promise<T | undefined>;
-    get<T = unknown>(keys: string[], options?: DurableObjectGetOptions): Promise<Map<string, T>>;
-    put<T>(key: string, value: T, options?: DurableObjectPutOptions): Promise<void>;
-    put<T>(entries: Record<string, T>, options?: DurableObjectPutOptions): Promise<void>;
-    delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
-    delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
-}
-export {};

package/build/types/storage_adapter/specific/cloudflare/kv/kv_storage.d.ts

@@ -1,18 +0,0 @@
-import { type IStorageAdapterConstructor, StorageAdapter } from "../../../StorageAdapter";
-import { type IStorageAdapterMethods_String } from "../../../storage_adapter.types";
-import { type ITypedStorage } from "../../../typed_storage/createTypedStorage";
-import type { IKVNamespace, IKVNamespacePutOptions } from "./kv_storage.types";
-export interface ICreateKVStorageMethodsOptions {
-    /** The `KVNamespace` binding, e.g. accessed off `env.MY_KV` inside a worker. */
-    kvNamespace: IKVNamespace;
-    /** Default options applied to every `put`, e.g. `{ expirationTtl }` for TTL-based eviction. */
-    defaultPutOptions?: IKVNamespacePutOptions;
-}
-export declare function createKVStorageMethods({ kvNamespace, defaultPutOptions, }: ICreateKVStorageMethodsOptions): IStorageAdapterMethods_String;
-export type TCreateKVStorageOptions = Omit<IStorageAdapterConstructor, "methods"> & ICreateKVStorageMethodsOptions;
-/**
- * Wraps a Cloudflare KV namespace binding in the generic StorageAdapter interface, e.g. for handing
- * to a ClientCryptoKeyLink so it can persist its keys inside KV.
- */
-export declare const createKVStorageAdapter: ({ kvNamespace, defaultPutOptions, ...options }: TCreateKVStorageOptions) => StorageAdapter;
-export declare function createKVTypedStorage<T extends Record<string, any>>(options: TCreateKVStorageOptions): ITypedStorage<T>;

package/build/types/storage_adapter/specific/cloudflare/kv/kv_storage.types.d.ts

@@ -1,22 +0,0 @@
-interface IKVNamespaceGetOptions {
-    cacheTtl?: number;
-}
-interface IKVNamespacePutOptions {
-    /** Absolute time (seconds since epoch) at which the key should expire. */
-    expiration?: number;
-    /** Relative TTL (in seconds) from now, after which the key should expire. */
-    expirationTtl?: number;
-    metadata?: unknown;
-}
-/**
- * Minimal subset of Cloudflare's `KVNamespace` binding that our storage adapter relies on. Values
- * are always written/read as strings (KV's `put` only accepts string/stream/buffer values), so the
- * adapter is a {@link EStorageAdapterType.string} adapter and JSON (de)serialization happens in the
- * generic `StorageAdapter`.
- */
-export interface IKVNamespace {
-    get(key: string, options?: IKVNamespaceGetOptions): Promise<string | null>;
-    put(key: string, value: string, options?: IKVNamespacePutOptions): Promise<void>;
-    delete(key: string): Promise<void>;
-}
-export type { IKVNamespaceGetOptions, IKVNamespacePutOptions };

package/build/types/storage_adapter/specific/memory/memory_storage.d.ts

@@ -1,28 +0,0 @@
-import { type IStorageAdapterConstructor, StorageAdapter } from "../../StorageAdapter";
-import { type IStorageAdapterMethods_Json, type IStorageAdapterMethods_String } from "../../storage_adapter.types";
-import { type ITypedStorage } from "../../typed_storage/createTypedStorage";
-export type TMemoryStorage_string = Map<string, string>;
-export type TMemoryStorage_json = Map<string, any>;
-/**
- *
- * Memory Storage [STRING]
- *
- */
-type TCreateMemoryStorageOptions_string = Omit<IStorageAdapterConstructor, "methods"> & {
-    memoryStorageMap?: TMemoryStorage_string;
-};
-export declare function createMemoryStorageMethods_string(memoryStorageMap?: TMemoryStorage_string): IStorageAdapterMethods_String;
-export declare const createMemoryStorageAdapter_string: (options?: TCreateMemoryStorageOptions_string) => StorageAdapter;
-export declare function createTypedMemoryStorage_string<T extends Record<string, any>>(options?: TCreateMemoryStorageOptions_string): ITypedStorage<T>;
-/**
- *
- * Memory Storage [JSON]
- *
- */
-type TCreateMemoryStorageOptions_json = Omit<IStorageAdapterConstructor, "methods"> & {
-    memoryStorageMap?: TMemoryStorage_json;
-};
-export declare function createMemoryStorageMethods_json(memoryStorageMap?: TMemoryStorage_json): IStorageAdapterMethods_Json;
-export declare const createMemoryStorageAdapter_json: (options?: TCreateMemoryStorageOptions_json) => StorageAdapter;
-export declare function createTypedMemoryStorage_json<T extends Record<string, any>>(options?: TCreateMemoryStorageOptions_json): ITypedStorage<T>;
-export {};

package/build/types/storage_adapter/storage_adapter.types.d.ts

@@ -1,21 +0,0 @@
-export declare enum EStorageAdapterType {
-    string = "string",
-    json = "json"
-}
-export interface IStorageAdapterMethods_String {
-    type: EStorageAdapterType.string;
-    setItem: (key: string, value: string) => Promise<void>;
-    getItem: (key: string) => Promise<string | null | undefined>;
-    removeItem: (key: string) => Promise<void>;
-}
-export interface IStorageAdapterMethods_Json {
-    type: EStorageAdapterType.json;
-    setItem: <T>(key: string, value: T) => Promise<void>;
-    getItem: <T>(key: string) => Promise<T | null | undefined>;
-    removeItem: (key: string) => Promise<void>;
-}
-export type TStorageAdapterMethods = IStorageAdapterMethods_String | IStorageAdapterMethods_Json;
-export interface IStorageKeyGetterAndSetter<T> {
-    get: () => Promise<T | undefined>;
-    set: (value: T) => Promise<void>;
-}

package/build/types/storage_adapter/typed_storage/createTypedStorage.d.ts

@@ -1,16 +0,0 @@
-import type { StringKeys } from "../../typescript/special_typescript_types";
-import type { StorageAdapter } from "../StorageAdapter";
-export interface ITypedStorage<T extends Record<string, any>> {
-    getJson<K extends StringKeys<T>>(key: K): Promise<T[K] | undefined>;
-    getJsonOrDef<K extends StringKeys<T>>(key: K, defVal: T[K]): Promise<T[K]>;
-    setJson<K extends StringKeys<T>>(key: K, val: T[K]): Promise<void>;
-    removeItem<K extends StringKeys<T>>(key: K): Promise<void>;
-    updateJson<K extends StringKeys<T>>(key: K, updater: (currentVal: T[K] | undefined) => T[K]): Promise<void>;
-    updateJsonWithDef<K extends StringKeys<T>>(key: K, defaultVal: T[K], updater: (currentVal: T[K]) => T[K]): Promise<void>;
-    clearAll(): Promise<void>;
-}
-interface ITypedStorage_Create_Input {
-    storageAdapter: StorageAdapter;
-}
-export declare function createTypedStorage<T extends Record<string, any>>({ storageAdapter, }: ITypedStorage_Create_Input): ITypedStorage<T>;
-export {};

package/build/types/typescript/special_typescript_types.d.ts

@@ -1 +0,0 @@
-export type StringKeys<T> = keyof T & string;