@qlover/fe-corekit 1.3.0 → 1.3.1

package/dist/index.d.ts

@@ -542,409 +542,6 @@ declare abstract class Executor<ExecutorConfig = unknown> {
     abstract execNoError<Result, Params = unknown>(data: unknown, task: Task<Result, Params>): Promise<Result | ExecutorError> | Result | ExecutorError;
 }
 
-/**
- * Request adapter configuration
- *
- * This type defines the configuration options for a request adapter.
- * It includes properties for URL, method, headers, and other request details.
- * The main purpose is to provide a flexible structure for configuring HTTP requests.
- *
- * @since 1.0.14
- */
-interface RequestAdapterConfig<RequestData = unknown> {
-    /**
-     * Request URL path
-     * Will be combined with baseURL if provided
-     *
-     * Processed by FetchURLPlugin during request
-     *
-     * @todo Change to URL | Request, add attribute `input`
-     * @example
-     * ```typescript
-     * url: '/users/1'
-     * ```
-     */
-    url?: string;
-    /**
-     * HTTP request methods supported by the executor
-     * Follows standard HTTP method definitions
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
-     * @example
-     * ```typescript
-     * method: 'GET'
-     * ```
-     */
-    method?: string;
-    /**
-     * Base URL for all requests
-     * Will be prepended to the request URL
-     *
-     * @example
-     * ```typescript
-     * baseURL: 'https://api.example.com'
-     * // url = /users/1 => https://api.example.com/users/1
-     * // url = users/1 => https://api.example.com/users/1
-     * ```
-     */
-    baseURL?: string;
-    /**
-     * Request body data
-     *
-     * Mapping fetch `body`
-     *
-     * @typeParam RequestData - The type of the request body data.
-     * @example
-     * ```typescript
-     * data: { name: 'John Doe' }
-     * ```
-     */
-    data?: RequestData;
-    /**
-     * URL query parameters
-     * Will be serialized and appended to the URL
-     *
-     * @example
-     * ```typescript
-     * params: { search: 'query' }
-     * ```
-     */
-    params?: Record<string, unknown>;
-    /**
-     * Request headers
-     *
-     * @example
-     * ```typescript
-     * headers: { 'Content-Type': 'application/json' }
-     * ```
-     */
-    headers?: {
-        [key: string]: unknown;
-    };
-    /**
-     * Response type
-     *
-     * Specifies the type of data that the server will respond with.
-     *
-     * @example
-     * ```typescript
-     * responseType: 'json'
-     * ```
-     */
-    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
-    /**
-     * Request ID, used to identify the request in the abort plugin.
-     */
-    requestId?: string;
-    [key: string]: any;
-}
-/**
- * Request adapter response
- *
- * This type defines the structure of a response from a request adapter.
- * It includes the response data, status, headers, and the original request configuration.
- *
- * @typeParam Req - The type of the request data.
- * @typeParam Res - The type of the response data.
- */
-interface RequestAdapterResponse<Req = unknown, Res = unknown> {
-    data: Res;
-    status: number;
-    statusText: string;
-    headers: {
-        [key: string]: unknown;
-    };
-    config: RequestAdapterConfig<Req>;
-    response: Response;
-    [key: string]: unknown;
-}
-/**
- * Request adapter interface
- *
- * This interface defines the contract for request adapters.
- * Adapters are responsible for handling the specific details of a request,
- * such as URL construction, headers, and response handling.
- *
- */
-interface RequestAdapterInterface<Config extends RequestAdapterConfig> {
-    /**
-     * The configuration for the request adapter.
-     *
-     * @type {Config}
-     */
-    readonly config: Config;
-    /**
-     * Sends a request using the specified options and returns a promise with the response.
-     *
-     * @typeParam Request - The type of the request data.
-     * @typeParam Response - The type of the response data.
-     * @param options - The configuration options for the request.
-     * @returns A promise that resolves to the response of the request.
-     * @example
-     * ```typescript
-     * adapter.request({ url: '/users', method: 'GET' }).then(response => console.log(response));
-     * ```
-     */
-    request<Request, Response>(options: RequestAdapterConfig<Request>): Promise<RequestAdapterResponse<Request, Response>>;
-    /**
-     * Retrieves the current configuration of the request adapter.
-     *
-     * @returns The current configuration.
-     * @example
-     * ```typescript
-     * const config = adapter.getConfig();
-     * ```
-     */
-    getConfig: () => Config;
-}
-
-/**
- * Represents a custom error class for handling request-related errors in the application
- *
- * RequestError extends the base ExecutorError class to provide specific error handling
- * for HTTP requests and fetch operations. It works in conjunction with RequestErrorID
- * to categorize different types of request failures.
- *
- * @since 1.0.14
- *
- * @example
- * ```typescript
- * try {
- *   await fetchData(url);
- * } catch (error) {
- *   if (error instanceof RequestError) {
- *     // Handle request specific error
- *     console.error('Request failed:', error.message);
- *   }
- * }
- * ```
- */
-declare class RequestError extends ExecutorError {
-}
-/**
- * Error IDs for different fetch request failure scenarios
- * Used to identify specific error types in error handling
- *
- * @description
- * This enum provides a standardized set of error identifiers that can be used
- * to categorize and handle different types of request failures in a consistent manner.
- * Each error ID represents a specific failure scenario that might occur during HTTP requests.
- *
- * @example
- * ```typescript
- * if (error.id === RequestErrorID.RESPONSE_NOT_OK) {
- *   // Handle non-200 response
- * } else if (error.id === RequestErrorID.ABORT_ERROR) {
- *   // Handle aborted request
- * }
- * ```
- */
-declare enum RequestErrorID {
-    /** Generic fetch request error */
-    REQUEST_ERROR = "REQUEST_ERROR",
-    /** Environment doesn't support fetch API */
-    ENV_FETCH_NOT_SUPPORT = "ENV_FETCH_NOT_SUPPORT",
-    /** No fetcher function provided */
-    FETCHER_NONE = "FETCHER_NONE",
-    /** Response status is not OK (not in 200-299 range) */
-    RESPONSE_NOT_OK = "RESPONSE_NOT_OK",
-    /** Request was aborted */
-    ABORT_ERROR = "ABORT_ERROR",
-    /** URL is not provided */
-    URL_NONE = "URL_NONE"
-}
-
-/**
- * Represents a transaction for a request.
- *
- * This interface defines a transaction that contains a request and a response.
- * It can be used to track the request and response of a transaction.
- *
- * @since 1.2.2
- */
-interface RequestTransactionInterface<Request, Response> {
-    /**
-     * The request object
-     */
-    request: Request;
-    /**
-     * The response object
-     */
-    response: Response;
-}
-
-/**
- * Generic interface for data serialization/deserialization operations
- * Provides a standard contract for implementing serialization strategies
- *
- * This is a generic interface, you can implement it with different serialization strategies
- *
- * @template T - Type of data to serialize/deserialize, defaults to any
- * @template R - Type of serialized result, defaults to string
- *
- * @since 1.0.10
- *
- * @example
- * ```typescript
- * // JSON serialization implementation
- * class JSONSerializer implements Serializer {
- *   serialize(data: any): string {
- *     return JSON.stringify(data);
- *   }
- *
- *   deserialize(data: string): any {
- *     return JSON.parse(data);
- *   }
- * }
- * ```
- */
-interface Serializer<T = unknown, R = string> {
-    /**
-     * Serializes data into a target format
-     * @since 1.0.10
-     * @param data - Data to serialize
-     * @returns Serialized representation
-     */
-    serialize(data: T): R;
-    /**
-     * Deserializes data from target format back to original form
-     * @since 1.0.10
-     * @param data - Data to deserialize
-     * @param defaultValue - Optional default value to return if deserialization fails
-     * @returns Original data structure
-     */
-    deserialize(data: R, defaultValue?: T): T;
-}
-
-/**
- * Interface representing a synchronous storage mechanism.
- *
- * @template Key - The type of keys used to identify stored values.
- * @template ValueType - The type of values stored, defaults to unknown.
- *
- * @example
- * ```typescript
- * const storage: SyncStorage<string, number> = ...;
- * storage.setItem('key', 123);
- * const value = storage.getItem('key', 0);
- * ```
- */
-interface SyncStorage<Key, ValueType = unknown> {
-    /**
-     * The number of items stored.
-     */
-    readonly length: number;
-    /**
-     * Stores a value with the specified key.
-     *
-     * @param key - The key to identify the stored value.
-     * @param value - The value to store.
-     * @param options - Optional parameters for storage.
-     */
-    setItem<T>(key: Key, value: T, options?: unknown): void;
-    /**
-     * Retrieves a value by key.
-     *
-     * @param key - The key of the value to retrieve.
-     * @param defaultValue - The default value to return if the key is not found.
-     * @param options - Optional parameters for retrieval.
-     * @returns The value associated with the key, or the default value if not found.
-     */
-    getItem<T extends ValueType>(key: Key, defaultValue?: T, options?: unknown): T | null;
-    /**
-     * Removes a value by key.
-     *
-     * @param key - The key of the value to remove.
-     * @param options - Optional parameters for removal.
-     */
-    removeItem(key: Key, options?: unknown): void;
-    /**
-     * Clears all stored values.
-     */
-    clear(): void;
-}
-/**
- * Interface representing an asynchronous storage mechanism.
- *
- * @template Key - The type of keys used to identify stored values.
- * @template ValueType - The type of values stored, defaults to unknown.
- *
- * @example
- *
- * ```typescript
- * const storage: AsyncStorage<string, number> = ...;
- * await storage.setItem('key', 123);
- * const value = await storage.getItem('key', 0);
- * ```
- *
- */
-interface AsyncStorage<Key, ValueType = unknown> {
-    /**
-     * The number of items stored.
-     */
-    readonly length: number;
-    /**
-     * Asynchronously stores a value with the specified key.
-     *
-     * @param key - The key to identify the stored value.
-     * @param value - The value to store.
-     * @param options - Optional parameters for storage.
-     * @returns A promise that resolves when the value is stored.
-     */
-    setItem<T>(key: Key, value: T, options?: unknown): Promise<void>;
-    /**
-     * Asynchronously retrieves a value by key.
-     *
-     * @param key - The key of the value to retrieve.
-     * @param defaultValue - The default value to return if the key is not found.
-     * @param options - Optional parameters for retrieval.
-     * @returns A promise that resolves to the value associated with the key, or the default value if not found.
-     */
-    getItem<T extends ValueType>(key: Key, defaultValue?: T, options?: unknown): Promise<T | null>;
-    /**
-     * Asynchronously removes a value by key.
-     *
-     * @param key - The key of the value to remove.
-     * @param options - Optional parameters for removal.
-     * @returns A promise that resolves when the value is removed.
-     */
-    removeItem(key: Key, options?: unknown): Promise<void>;
-    /**
-     * Asynchronously clears all stored values.
-     *
-     * @returns A promise that resolves when all values are cleared.
-     */
-    clear(): Promise<void>;
-}
-
-/**
- * Get the value type of an object
- *
- * @since 1.0.14
- *
- * @example
- * ```ts
- * type T = { a: number; b: string };
- * type V = ValueOf<T>; // V is number | string
- * ```
- */
-type ValueOf<T> = T[keyof T];
-/**
- * Get the intersection type of two types
- *
- * @since 1.0.14
- *
- * @example
- * ```ts
- * type T1 = { a: number; b: string };
- * type T2 = { a: number; c: boolean };
- * type I = Intersection<T1, T2>; // I is { a: number }
- * ```
- */
-type Intersection<T1, T2> = {
-    [P in keyof T1 & keyof T2]: T1[P] | T2[P];
-};
-
 /**
  * Asynchronous implementation of the Executor pattern
  *
@@ -1496,202 +1093,234 @@ declare class RetryPlugin implements ExecutorPlugin {
 }
 
 /**
- * Available log levels
- * Used to categorize and control log output
- */
-declare const LEVELS: {
-    readonly LOG: "LOG";
-    readonly INFO: "INFO";
-    readonly ERROR: "ERROR";
-    readonly WARN: "WARN";
-    readonly DEBUG: "DEBUG";
-};
-type LogLevel = (typeof LEVELS)[keyof typeof LEVELS];
-type LogArgument = unknown;
-/**
- * Options for execution logging
- * @interface ExecOptions
- */
-type ExecOptions = {
-    /** When true, commands are only logged but not executed */
-    isDryRun?: boolean;
-    /** When true, indicates the command is from an external source */
-    isExternal?: boolean;
-};
-/**
- * Logger class providing various logging methods
- *
- * The Logger class supports multiple log levels and can be configured
- * to operate in different environments such as CI, dry run, debug, and silent modes.
- *
- * - Core Idea: Provide a flexible and configurable logging utility.
- * - Main Function: Log messages at different levels with optional environment-specific behavior.
- * - Main Purpose: Facilitate debugging and monitoring by providing structured log output.
+ * Request adapter configuration
  *
- * @class Logger
- * @example
- * ```typescript
- * // Create a logger instance
- * const logger = new Logger({ debug: true });
+ * This type defines the configuration options for a request adapter.
+ * It includes properties for URL, method, headers, and other request details.
+ * The main purpose is to provide a flexible structure for configuring HTTP requests.
  *
- * // Log messages at different levels
- * logger.info('This is an info message');
- * logger.error('This is an error message');
- * logger.debug('This is a debug message');
- * ```
+ * @since 1.0.14
  */
-declare class Logger {
-    protected isCI: boolean;
-    protected isDryRun: boolean;
-    protected isDebug: boolean;
-    protected isSilent: boolean;
+interface RequestAdapterConfig<RequestData = unknown> {
     /**
-     * Creates a new Logger instance
-     *
-     * This constructor initializes the Logger with configuration options
-     * that determine its behavior in different environments.
+     * Request URL path
+     * Will be combined with baseURL if provided
      *
-     * @param options - Logger configuration options
-     * @param {boolean} options.isCI  - Whether running in CI environment
-     * @param {boolean} options.dryRun  - Whether to perform dry run only
-     * @param {boolean} options.debug  - Whether to enable debug output
-     * @param {boolean} options.silent  - Whether to suppress all output
+     * Processed by FetchURLPlugin during request
      *
+     * @todo Change to URL | Request, add attribute `input`
      * @example
      * ```typescript
-     * const logger = new Logger({ isCI: true, debug: true });
+     * url: '/users/1'
      * ```
      */
-    constructor({ isCI, dryRun, debug, silent }?: {
-        isCI?: boolean | undefined;
-        dryRun?: boolean | undefined;
-        debug?: boolean | undefined;
-        silent?: boolean | undefined;
-    });
+    url?: string;
     /**
-     * Core logging method
-     * Handles actual console output based on configuration
-     *
-     * @param level - Log level for the message
-     * @param args - Arguments to log
+     * HTTP request methods supported by the executor
+     * Follows standard HTTP method definitions
      *
+     * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
      * @example
      * ```typescript
-     * this.print(LEVELS.INFO, 'Information message');
+     * method: 'GET'
      * ```
      */
-    protected print(_level: LogLevel, ...args: LogArgument[]): void;
+    method?: string;
     /**
-     * Adds prefix to log messages
-     * Can be overridden to customize log format
-     *
-     * @param value - The prefix value
-     * @param _level - Log level (optional)
-     * @returns Formatted prefix string or array
+     * Base URL for all requests
+     * Will be prepended to the request URL
      *
      * @example
      * ```typescript
-     * const prefix = this.prefix('INFO');
+     * baseURL: 'https://api.example.com'
+     * // url = /users/1 => https://api.example.com/users/1
+     * // url = users/1 => https://api.example.com/users/1
      * ```
      */
-    prefix(value: string, _level?: LogLevel): string | string[];
+    baseURL?: string;
     /**
-     * Basic log output
+     * Request body data
      *
-     * @param args - Values to log
+     * Mapping fetch `body`
      *
+     * @typeParam RequestData - The type of the request body data.
      * @example
      * ```typescript
-     * logger.log('This is a log message');
+     * data: { name: 'John Doe' }
      * ```
      */
-    log(...args: LogArgument[]): void;
+    data?: RequestData;
     /**
-     * Informational log output
-     *
-     * @param args - Values to log
+     * URL query parameters
+     * Will be serialized and appended to the URL
      *
      * @example
      * ```typescript
-     * logger.info('This is an info message');
+     * params: { search: 'query' }
      * ```
      */
-    info(...args: LogArgument[]): void;
+    params?: Record<string, unknown>;
     /**
-     * Warning log output
-     *
-     * @param args - Values to log
+     * Request headers
      *
      * @example
      * ```typescript
-     * logger.warn('This is a warning message');
+     * headers: { 'Content-Type': 'application/json' }
      * ```
      */
-    warn(...args: LogArgument[]): void;
+    headers?: {
+        [key: string]: unknown;
+    };
     /**
-     * Error log output
+     * Response type
      *
-     * @param args - Values to log
+     * Specifies the type of data that the server will respond with.
      *
      * @example
      * ```typescript
-     * logger.error('This is an error message');
+     * responseType: 'json'
      * ```
      */
-    error(...args: LogArgument[]): void;
+    responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
     /**
-     * Debug log output
-     *
-     * - Only active when debug mode is enabled
-     * - Formats objects as JSON strings
-     *
-     * @param args - Values to log
-     *
-     * @example
-     * ```typescript
-     * logger.debug('This is a debug message');
-     * ```
+     * Request ID, used to identify the request in the abort plugin.
      */
-    debug(...args: LogArgument[]): void;
+    requestId?: string;
+    [key: string]: any;
+}
+/**
+ * Request adapter response
+ *
+ * This type defines the structure of a response from a request adapter.
+ * It includes the response data, status, headers, and the original request configuration.
+ *
+ * @typeParam Req - The type of the request data.
+ * @typeParam Res - The type of the response data.
+ */
+interface RequestAdapterResponse<Req = unknown, Res = unknown> {
+    data: Res;
+    status: number;
+    statusText: string;
+    headers: {
+        [key: string]: unknown;
+    };
+    config: RequestAdapterConfig<Req>;
+    response: Response;
+    [key: string]: unknown;
+}
+/**
+ * Request adapter interface
+ *
+ * This interface defines the contract for request adapters.
+ * Adapters are responsible for handling the specific details of a request,
+ * such as URL construction, headers, and response handling.
+ *
+ */
+interface RequestAdapterInterface<Config extends RequestAdapterConfig> {
     /**
-     * Verbose log output
-     *
-     * - Only active when debug mode is enabled
-     * - Uses purple color for output
-     *
-     * @param args - Values to log
+     * The configuration for the request adapter.
      *
-     * @example
-     * ```typescript
-     * logger.verbose('This is a verbose message');
-     * ```
+     * @type {Config}
      */
-    verbose(...args: LogArgument[]): void;
+    readonly config: Config;
     /**
-     * Command execution logging
-     * Supports dry run mode and external command indication
-     *
-     * @param args - Command arguments and options
+     * Sends a request using the specified options and returns a promise with the response.
      *
+     * @typeParam Request - The type of the request data.
+     * @typeParam Response - The type of the response data.
+     * @param options - The configuration options for the request.
+     * @returns A promise that resolves to the response of the request.
      * @example
      * ```typescript
-     * logger.exec('npm', 'install', { isDryRun: true });
-     * logger.exec(['git', 'commit', '-m', 'feat: update'], { isExternal: true });
+     * adapter.request({ url: '/users', method: 'GET' }).then(response => console.log(response));
      * ```
      */
-    exec(...args: (LogArgument | ExecOptions)[]): void;
+    request<Request, Response>(options: RequestAdapterConfig<Request>): Promise<RequestAdapterResponse<Request, Response>>;
     /**
-     * Obtrusive log output
-     * Adds extra line breaks in non-CI environments
-     *
-     * @param args - Values to log
+     * Retrieves the current configuration of the request adapter.
      *
+     * @returns The current configuration.
      * @example
      * ```typescript
-     * logger.obtrusive('This is an important message');
+     * const config = adapter.getConfig();
      * ```
      */
-    obtrusive(...args: LogArgument[]): void;
+    getConfig: () => Config;
+}
+
+/**
+ * Represents a custom error class for handling request-related errors in the application
+ *
+ * RequestError extends the base ExecutorError class to provide specific error handling
+ * for HTTP requests and fetch operations. It works in conjunction with RequestErrorID
+ * to categorize different types of request failures.
+ *
+ * @since 1.0.14
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetchData(url);
+ * } catch (error) {
+ *   if (error instanceof RequestError) {
+ *     // Handle request specific error
+ *     console.error('Request failed:', error.message);
+ *   }
+ * }
+ * ```
+ */
+declare class RequestError extends ExecutorError {
+}
+/**
+ * Error IDs for different fetch request failure scenarios
+ * Used to identify specific error types in error handling
+ *
+ * @description
+ * This enum provides a standardized set of error identifiers that can be used
+ * to categorize and handle different types of request failures in a consistent manner.
+ * Each error ID represents a specific failure scenario that might occur during HTTP requests.
+ *
+ * @example
+ * ```typescript
+ * if (error.id === RequestErrorID.RESPONSE_NOT_OK) {
+ *   // Handle non-200 response
+ * } else if (error.id === RequestErrorID.ABORT_ERROR) {
+ *   // Handle aborted request
+ * }
+ * ```
+ */
+declare enum RequestErrorID {
+    /** Generic fetch request error */
+    REQUEST_ERROR = "REQUEST_ERROR",
+    /** Environment doesn't support fetch API */
+    ENV_FETCH_NOT_SUPPORT = "ENV_FETCH_NOT_SUPPORT",
+    /** No fetcher function provided */
+    FETCHER_NONE = "FETCHER_NONE",
+    /** Response status is not OK (not in 200-299 range) */
+    RESPONSE_NOT_OK = "RESPONSE_NOT_OK",
+    /** Request was aborted */
+    ABORT_ERROR = "ABORT_ERROR",
+    /** URL is not provided */
+    URL_NONE = "URL_NONE"
+}
+
+/**
+ * Represents a transaction for a request.
+ *
+ * This interface defines a transaction that contains a request and a response.
+ * It can be used to track the request and response of a transaction.
+ *
+ * @since 1.2.2
+ */
+interface RequestTransactionInterface<Request, Response> {
+    /**
+     * The request object
+     */
+    request: Request;
+    /**
+     * The response object
+     */
+    response: Response;
 }
 
 /**
@@ -2455,6 +2084,49 @@ declare class RequestTransaction<Config extends RequestAdapterConfig<unknown>> e
     patch<Transaction = unknown>(url: string, data?: Transaction extends RequestTransactionInterface<Config, unknown> ? Transaction['request']['data'] : Config['data'], config?: Omit<Config, 'url' | 'method' | 'data'>): Promise<Transaction extends RequestTransactionInterface<Config, unknown> ? Transaction['response'] : RequestAdapterResponse<unknown, Transaction>>;
 }
 
+/**
+ * Generic interface for data serialization/deserialization operations
+ * Provides a standard contract for implementing serialization strategies
+ *
+ * This is a generic interface, you can implement it with different serialization strategies
+ *
+ * @template T - Type of data to serialize/deserialize, defaults to any
+ * @template R - Type of serialized result, defaults to string
+ *
+ * @since 1.0.10
+ *
+ * @example
+ * ```typescript
+ * // JSON serialization implementation
+ * class JSONSerializer implements Serializer {
+ *   serialize(data: any): string {
+ *     return JSON.stringify(data);
+ *   }
+ *
+ *   deserialize(data: string): any {
+ *     return JSON.parse(data);
+ *   }
+ * }
+ * ```
+ */
+interface Serializer<T = unknown, R = string> {
+    /**
+     * Serializes data into a target format
+     * @since 1.0.10
+     * @param data - Data to serialize
+     * @returns Serialized representation
+     */
+    serialize(data: T): R;
+    /**
+     * Deserializes data from target format back to original form
+     * @since 1.0.10
+     * @param data - Data to deserialize
+     * @param defaultValue - Optional default value to return if deserialization fails
+     * @returns Original data structure
+     */
+    deserialize(data: R, defaultValue?: T): T;
+}
+
 /**
  * Enhanced JSON serialization implementation that combines standard JSON API with additional features
  *
@@ -2697,6 +2369,107 @@ declare class Base64Serializer implements Serializer<string, string> {
     private makeUrlUnsafe;
 }
 
+/**
+ * Interface representing a synchronous storage mechanism.
+ *
+ * @template Key - The type of keys used to identify stored values.
+ * @template ValueType - The type of values stored, defaults to unknown.
+ *
+ * @example
+ * ```typescript
+ * const storage: SyncStorage<string, number> = ...;
+ * storage.setItem('key', 123);
+ * const value = storage.getItem('key', 0);
+ * ```
+ */
+interface SyncStorage<Key, ValueType = unknown> {
+    /**
+     * The number of items stored.
+     */
+    readonly length: number;
+    /**
+     * Stores a value with the specified key.
+     *
+     * @param key - The key to identify the stored value.
+     * @param value - The value to store.
+     * @param options - Optional parameters for storage.
+     */
+    setItem<T>(key: Key, value: T, options?: unknown): void;
+    /**
+     * Retrieves a value by key.
+     *
+     * @param key - The key of the value to retrieve.
+     * @param defaultValue - The default value to return if the key is not found.
+     * @param options - Optional parameters for retrieval.
+     * @returns The value associated with the key, or the default value if not found.
+     */
+    getItem<T extends ValueType>(key: Key, defaultValue?: T, options?: unknown): T | null;
+    /**
+     * Removes a value by key.
+     *
+     * @param key - The key of the value to remove.
+     * @param options - Optional parameters for removal.
+     */
+    removeItem(key: Key, options?: unknown): void;
+    /**
+     * Clears all stored values.
+     */
+    clear(): void;
+}
+/**
+ * Interface representing an asynchronous storage mechanism.
+ *
+ * @template Key - The type of keys used to identify stored values.
+ * @template ValueType - The type of values stored, defaults to unknown.
+ *
+ * @example
+ *
+ * ```typescript
+ * const storage: AsyncStorage<string, number> = ...;
+ * await storage.setItem('key', 123);
+ * const value = await storage.getItem('key', 0);
+ * ```
+ *
+ */
+interface AsyncStorage<Key, ValueType = unknown> {
+    /**
+     * The number of items stored.
+     */
+    readonly length: number;
+    /**
+     * Asynchronously stores a value with the specified key.
+     *
+     * @param key - The key to identify the stored value.
+     * @param value - The value to store.
+     * @param options - Optional parameters for storage.
+     * @returns A promise that resolves when the value is stored.
+     */
+    setItem<T>(key: Key, value: T, options?: unknown): Promise<void>;
+    /**
+     * Asynchronously retrieves a value by key.
+     *
+     * @param key - The key of the value to retrieve.
+     * @param defaultValue - The default value to return if the key is not found.
+     * @param options - Optional parameters for retrieval.
+     * @returns A promise that resolves to the value associated with the key, or the default value if not found.
+     */
+    getItem<T extends ValueType>(key: Key, defaultValue?: T, options?: unknown): Promise<T | null>;
+    /**
+     * Asynchronously removes a value by key.
+     *
+     * @param key - The key of the value to remove.
+     * @param options - Optional parameters for removal.
+     * @returns A promise that resolves when the value is removed.
+     */
+    removeItem(key: Key, options?: unknown): Promise<void>;
+    /**
+     * Asynchronously clears all stored values.
+     *
+     * @returns A promise that resolves when all values are cleared.
+     */
+    clear(): Promise<void>;
+}
+
 /**
  * Represents a storage mechanism for JSON-serializable data.
  *
@@ -2833,5 +2606,33 @@ declare class JSONStorage implements SyncStorage<string> {
     clear(): void;
 }
 
-export { AsyncExecutor, Base64Serializer, Executor, ExecutorError, FetchAbortPlugin, FetchURLPlugin, JSONSerializer, JSONStorage, LEVELS, Logger, RequestAdapterAxios, RequestAdapterFetch, RequestError, RequestErrorID, RequestManager, RequestScheduler, RequestTransaction, RetryPlugin, SyncExecutor };
-export type { AsyncStorage, Encryptor, ExecOptions, ExecutorContext, ExecutorPlugin, HookRuntimes, Intersection, LogArgument, LogLevel, PromiseTask, RequestAdapterConfig, RequestAdapterFetchConfig, RequestAdapterInterface, RequestAdapterResponse, RequestTransactionInterface, RetryOptions, Serializer, SyncStorage, SyncTask, Task, ValueOf };
+/**
+ * Get the value type of an object
+ *
+ * @since 1.0.14
+ *
+ * @example
+ * ```ts
+ * type T = { a: number; b: string };
+ * type V = ValueOf<T>; // V is number | string
+ * ```
+ */
+type ValueOf<T> = T[keyof T];
+/**
+ * Get the intersection type of two types
+ *
+ * @since 1.0.14
+ *
+ * @example
+ * ```ts
+ * type T1 = { a: number; b: string };
+ * type T2 = { a: number; c: boolean };
+ * type I = Intersection<T1, T2>; // I is { a: number }
+ * ```
+ */
+type Intersection<T1, T2> = {
+    [P in keyof T1 & keyof T2]: T1[P] | T2[P];
+};
+
+export { AsyncExecutor, Base64Serializer, Executor, ExecutorError, FetchAbortPlugin, FetchURLPlugin, JSONSerializer, JSONStorage, RequestAdapterAxios, RequestAdapterFetch, RequestError, RequestErrorID, RequestManager, RequestScheduler, RequestTransaction, RetryPlugin, SyncExecutor };
+export type { AsyncStorage, Encryptor, ExecutorContext, ExecutorPlugin, HookRuntimes, Intersection, PromiseTask, RequestAdapterConfig, RequestAdapterFetchConfig, RequestAdapterInterface, RequestAdapterResponse, RequestTransactionInterface, RetryOptions, Serializer, SyncStorage, SyncTask, Task, ValueOf };