@qlover/fe-corekit 1.3.0 → 1.3.1

package/dist/interface/index.d.ts

@@ -1,947 +0,0 @@
-/**
- * Generic interface for encryption/decryption operations
- * Provides a standard contract for implementing encryption strategies
- *
- * @template ValueType - Type of value to encrypt/decrypt
- * @template EncryptResult - Type of encrypted result
- *
- * @example
- * ```typescript
- * // String encryption implementation
- * class StringEncryptor implements Encryptor<string, string> {
- *   encrypt(value: string): string {
- *     // Encryption logic
- *   }
- *
- *   decrypt(encryptedData: string): string {
- *     // Decryption logic
- *   }
- * }
- * ```
- */
-interface Encryptor<ValueType, EncryptResult> {
-    /**
-     * Encrypts the provided value
-     * @param value - Value to encrypt
-     * @returns Encrypted result
-     */
-    encrypt(value: ValueType): EncryptResult;
-    /**
-     * Decrypts the encrypted data
-     * @param encryptedData - Data to decrypt
-     * @returns Original value
-     */
-    decrypt(encryptedData: EncryptResult): ValueType;
-}
-
-/**
- * Custom error class for executor operations.
- *
- * This class provides a structured way to handle errors that occur during executor operations.
- * It extends the standard Error class to include an error identification string, which can be used
- * to categorize and manage errors more effectively.
- *
- * @category Executor
- *
- * @example
- * ```typescript
- * try {
- *   // some executor operation
- * } catch (error) {
- *   throw new ExecutorError('EXECUTOR_ERROR', error);
- * }
- * ```
- *
- * @example
- *
- * create an error with a message from a string
- *
- * ```typescript
- * const error = new ExecutorError('ERROR_ID', 'This is an error message');
- *
- * // => error.message is 'This is an error message'
- * // => error.id is 'ERROR_ID'
- * ```
- */
-declare class ExecutorError extends Error {
-    id: string;
-    /**
-     * Constructs a new ExecutorError.
-     *
-     * if originalError is a string, it will be used as the error message.
-     * if originalError is an Error object, its message will be used as the error message.
-     * if originalError is not provided, the error message will be the id.
-     *
-     * @param id - A unique identifier for the error, used for categorization and tracking.
-     * @param originalError - The original error message or Error object that triggered this error.
-     *                        This parameter is optional.
-     */
-    constructor(id: string, originalError?: string | Error);
-}
-
-/**
- * Represents the context in which a task is executed.
- *
- * This interface is designed to encapsulate the necessary information
- * for executing a task, including parameters, potential errors, and
- * the return value. It allows for additional properties to be added
- * dynamically, making it flexible for various use cases.
- *
- * @template Params - The type of parameters that the task accepts.
- *
- * @since 1.0.14
- *
- * @example
- * ```typescript
- * const context: ExecutorContextInterface<MyParams> = {
- *   parameters: { id: 1 },
- *   error: null,
- *   returnValue: 'Success'
- * };
- * ```
- */
-interface ExecutorContext<Params = unknown> {
-    /**
-     * The error that occurred during the execution of the task.
-     *
-     * This property is optional and will be populated if an error
-     * occurs during task execution.
-     *
-     * @type {Error | undefined}
-     */
-    error?: Error;
-    /**
-     * The parameters passed to the task.
-     *
-     * These parameters are used to execute the task and are of a generic
-     * type, allowing for flexibility in the types of parameters that can
-     * be passed.
-     *
-     * @type {Params}
-     */
-    parameters: Params;
-    /**
-     * The return value of the task.
-     *
-     * This property is optional and will contain the result of the task
-     * execution if it completes successfully.
-     *
-     * @type {unknown | undefined}
-     */
-    returnValue?: unknown;
-    /**
-     * The runtime information of the task.
-     *
-     * The current runtime of each hook.
-     *
-     * This property is optional and will contain the runtime information
-     * of the task if it is executed.
-     *
-     * property is read-only
-     *
-     * will return a frozen object that will be cleared after the chain execution is complete.
-     *
-     */
-    hooksRuntimes: HookRuntimes;
-}
-interface HookRuntimes {
-    hookName?: string;
-    /**
-     * The return value of the task.
-     *
-     * Readonly
-     */
-    returnValue?: unknown;
-    /**
-     * 执行次数
-     */
-    times?: number;
-    /**
-     * 是否中断链
-     */
-    breakChain?: boolean;
-    /**
-     * 如果有返回值，是否中断链
-     *
-     * 一般常用于需要返回一个值时中断链,比如 onError 声明周期
-     */
-    returnBreakChain?: boolean;
-    [key: string]: unknown;
-}
-
-/**
- * Type definition for promise-based task
- * @template T - Return type of the task
- * @template D - Input data type for the task
- * @example
- * ```typescript
- * const promiseTask: PromiseTask<string, number> = async (data: number) => {
- *   return `Result: ${data}`;
- * };
- * ```
- * @category ExecutorPlugin
- */
-type PromiseTask<Result, Params> = (context: ExecutorContext<Params>) => Promise<Result>;
-/**
- * Type definition for synchronous task
- * @template Result - Return type of the task
- * @template D - Input data type for the task
- * @example
- * ```typescript
- * const syncTask: SyncTask<string, number> = (data: number) => {
- *   return `Result: ${data}`;
- * };
- * ```
- * @category ExecutorPlugin
- */
-type SyncTask<Result, Params> = (context: ExecutorContext<Params>) => Result;
-/**
- * Union type for both promise and sync tasks
- * @template T - Return type of the task
- * @template D - Input data type for the task
- * @category ExecutorPlugin
- */
-type Task<Result, Params> = PromiseTask<Result, Params> | SyncTask<Result, Params>;
-/**
- * Base plugin class for extending executor functionality.
- *
- * Plugins provide a way to intercept and modify the execution flow at different stages:
- * - Before execution (onBefore)
- * - After successful execution (onSuccess)
- * - On error (onError)
- * - Custom execution logic (onExec)
- *
- * LifeCycle:
- *
- * **onBefore**
- *   - onBefore can modify the input data before it reaches the task, before exec is called.
- *   - The parameter of the first plugin's onBefore is the input data of exec.
- *   - The parameter of other plugins' onBefore is the return value of previous plugin's onBefore.
- *   - Also, not return value, will use first plugin's onBefore return value or exec's input data.
- *   - The parameter of the first plugin's onBefore is the input data of exec.
- *   - If any plugin's onBefore throws an error, it immediately stops the onBefore chain and enters the onError chain.
- *
- * **onExec**
- *   - onExec can modify the task before it is executed.
- *   - Use first plugin's onExec return value or exec's task.
- *   - The exec execution is only allowed to be modified once, so only the first onExec lifecycle method registered in the plugins list will be used.
- *
- * **onSuccess**
- *   - When call exec, onSuccess will be executed after onExec.
- *   - onSuccess accept the result of previous plugin's onSuccess, and can return a new result to the next plugin's onSuccess.
- *   - That means, if any plugin's onSuccess returns a new value, the next plugin's onSuccess will accept the value of previous plugin's onSuccess as parameter,
- *   - and can continue to return a new value, until the last plugin's onSuccess. The entire chain will not stop.
- *   - The parameter of the first plugin's onSuccess is the result of exec.
- *   - If any plugin's onSuccess throws an error, it immediately stops the onSuccess chain and enters the onError chain.
- *
- * **onError**
- *   - When an error occurs during call exec, all plugins' onError will be ordered executed.
- *   - After exec, all errors will be wrapped with ExecutorError.
- *   - If onError of any of the plugins returns an error, the error is thrown and the entire chain is stopped, but execNoError only return the error.
- *   - If any plugin's onError throws an error, it immediately stops the entire chain and throws the error, since errors in the error chain cannot be caught. Whether exec or execNoError.
- *   - If all plugins' onError neither return nor throw an error, wrapping raw Errors with ExecutorError and throw.
- *   - If execNoError is called, the first error encountered is returned, and the entire lifecycle is terminated.
- *
- *
- * **execNoError returns all errors as they are.**
- *
- * @template T - Type of data being processed
- * @template R - Type of result after processing
- *
- * @example
- * ```typescript
- * class LoggerPlugin extends ExecutorPlugin {
- *   onBefore(data: unknown) {
- *     console.log('Before execution:', data);
- *     return data;
- *   }
- *
- *   onSuccess(result: unknown) {
- *     console.log('Execution succeeded:', result);
- *     return result;
- *   }
- *
- *   onError(error: Error) {
- *     console.error('Execution failed:', error);
- *     throw error;
- *   }
- * }
- * ```
- * @category ExecutorPlugin
- */
-interface ExecutorPlugin<T = unknown> {
-    /**
-     * The pluginName of the plugin.
-     *
-     * Plugins with the same pluginName will be merged.
-     */
-    readonly pluginName: string;
-    /**
-     * Indicates if only one instance of this plugin should exist in the executor
-     * When true, attempting to add duplicate plugins will result in a warning
-     */
-    readonly onlyOne?: boolean;
-    /**
-     * Controls whether the plugin is active for specific hook executions
-     * @param name - Name of the hook being executed
-     * @param args - Arguments passed to the hook
-     * @returns Boolean indicating if the plugin should be executed
-     *
-     * @example
-     * ```typescript
-     * enabled(name: keyof ExecutorPlugin, context: ExecutorContextInterface<T>) {
-     *   // Only enable for error handling
-     *   return name === 'onError';
-     * }
-     * ```
-     */
-    enabled?(name: keyof ExecutorPlugin, context?: ExecutorContext<T>): boolean;
-    /**
-     * Hook executed before the main task
-     * Can modify the input data before it reaches the task
-     * @param data - Input data
-     * @returns Modified data or Promise of modified data
-     */
-    onBefore?(context: ExecutorContext<T>): void | Promise<void>;
-    /**
-     * Error handling hook
-     * - For `exec`: returning a value or throwing will break the chain
-     * - For `execNoError`: returning a value or throwing will return the error
-     *
-     * Because `onError` can break the chain, best practice is each plugin only handle plugin related error
-     *
-     * @param error - Error that occurred
-     * @param data - Original input data
-     * @returns ExecutorError, void, or Promise of either
-     */
-    onError?(context: ExecutorContext<T>): Promise<ExecutorError | Error | void> | ExecutorError | Error | void;
-    /**
-     * Hook executed after successful task completion
-     * Can transform the task result
-     * @param result - Task execution result
-     * @returns Modified result or Promise of modified result
-     */
-    onSuccess?(context: ExecutorContext<T>): void | Promise<void>;
-    /**
-     * Custom execution logic hook
-     * Only the first plugin with onExec will be used
-     * @param task - Task to be executed
-     * @returns Task result or Promise of result
-     */
-    onExec?(context: ExecutorContext<unknown>, task: Task<unknown, unknown>): Promise<unknown> | unknown;
-}
-
-/**
- * Base executor class providing plugin management and execution pipeline
- *
- * The Executor pattern implements a pluggable execution pipeline that allows:
- * 1. Pre-processing of input data
- * 2. Post-processing of results
- * 3. Error handling
- * 4. Custom execution logic
- *
- * execNoError returns all errors as they are., and if there is a plugin onerror handler chain in which an error occurs, it will also return the error instead of throwing it.
- *
- * @abstract
- * @class Executor
- * @category Executor
- * @example
- * ```typescript
- * // Create an executor instance
- * const executor = new AsyncExecutor();
- *
- * // Add plugins
- * executor.use(new LoggerPlugin());
- * executor.use(new RetryPlugin({ maxAttempts: 3 }));
- *
- * // Execute a task
- * const result = await executor.exec(async (data) => {
- *   return await someAsyncOperation(data);
- * });
- * ```
- */
-declare abstract class Executor<ExecutorConfig = unknown> {
-    protected config?: ExecutorConfig | undefined;
-    /**
-     * Array of active plugins
-     *
-     * - Purpose: Stores and manages executor plugins
-     * - Core Concept: Ordered plugin pipeline
-     * - Main Features:
-     *  - Maintains plugin execution order
-     *  - Supports plugin lifecycle management
-     * - Primary Use: Plugin orchestration and execution
-     *
-     * @example
-     * ```typescript
-     * protected plugins = [
-     *   new LoggerPlugin(),
-     *   new RetryPlugin()
-     * ];
-     * ```
-     */
-    protected plugins: ExecutorPlugin[];
-    /**
-     * Creates a new Executor instance
-     *
-     * - Purpose: Initialize executor with optional configuration
-     * - Core Concept: Configurable executor setup
-     * - Main Features: Configuration injection
-     * - Primary Use: Executor instantiation
-     *
-     * @param {ExecutorConfig} config - Optional configuration object
-     *
-     * @example
-     * ```typescript
-     * const executor = new Executor({
-     *   // config options
-     * });
-     * ```
-     */
-    constructor(config?: ExecutorConfig | undefined);
-    /**
-     * Add a plugin to the executor
-     *
-     * - Purpose: Extends executor functionality through plugins
-     * - Core Concept: Plugin registration and deduplication
-     * - Main Features:
-     *  - Prevents duplicate plugins if onlyOne is true
-     *  - Maintains plugin execution order
-     * - Primary Use: Adding new capabilities to executor
-     *
-     * @param plugin - Plugin instance to add
-     *
-     * @example
-     * ```typescript
-     * executor.use(new LoggerPlugin());
-     * executor.use(new RetryPlugin({ maxAttempts: 3 }));
-     * ```
-     *
-     * @example
-     *
-     * Use a plain object as a plugin
-     * ```typescript
-     * executor.use({
-     *   onBefore: (data) => ({ ...data, modified: true })
-     * });
-     * ```
-     */
-    use(plugin: ExecutorPlugin): void;
-    /**
-     * Execute a plugin hook
-     *
-     * - Purpose: Provides plugin hook execution mechanism
-     * - Core Concept: Plugin lifecycle management
-     * - Main Features:
-     *  - Dynamic hook execution
-     *  - Support for async and sync hooks
-     * - Primary Use: Running plugin lifecycle methods
-     *
-     * @param plugins - Plugins to execute
-     * @param name - Hook name to execute
-     * @param args - Arguments for the hook
-     *
-     * @example
-     * ```typescript
-     * await executor.runHook(plugins, 'beforeExec', data);
-     * ```
-     */
-    abstract runHooks(plugins: ExecutorPlugin[], name: keyof ExecutorPlugin, ...args: unknown[]): void | unknown | Promise<void | unknown>;
-    /**
-     * Execute a task with plugin pipeline
-     *
-     * - Purpose: Core task execution with plugin support
-     * - Core Concept: Task execution pipeline
-     * - Main Features:
-     *  - Plugin hook integration
-     *  - Error handling
-     * - Primary Use: Running tasks through the executor pipeline
-     *
-     * @param task - Task to execute
-     * @param data - Optional input data for task
-     * @throws {ExecutorError} If task execution fails
-     *
-     * @example
-     * ```typescript
-     * const result = await executor.exec(async (data) => {
-     *   return await processData(data);
-     * });
-     * ```
-     */
-    abstract exec<Result, Params = unknown>(task: Task<Result, Params>): Promise<Result> | Result;
-    /**
-     * Execute a task with plugin pipeline and input data
-     *
-     * - Purpose: Core task execution with plugin support and input data
-     * - Core Concept: Task execution pipeline with data
-     * - Main Features:
-     *  - Plugin hook integration
-     *  - Error handling
-     * - Primary Use: Running tasks with input data through the executor pipeline
-     *
-     * @param data - Input data for task
-     * @param task - Task to execute
-     * @throws {ExecutorError} If task execution fails
-     *
-     * @example
-     * ```typescript
-     * const result = await executor.exec(data, async (data) => {
-     *   return await processData(data);
-     * });
-     * ```
-     */
-    abstract exec<Result, Params = unknown>(data: unknown, task: Task<Result, Params>): Promise<Result> | Result;
-    /**
-     * Execute a task without throwing errors
-     *
-     * - Purpose: Safe task execution with error wrapping
-     * - Core Concept: Error-safe execution pipeline
-     * - Main Features:
-     *  - Error wrapping in ExecutorError
-     *  - Non-throwing execution
-     * - Primary Use: When error handling is preferred over exceptions
-     *
-     * @param task - Task to execute
-     *
-     * @example
-     * ```typescript
-     * const result = await executor.execNoError(async (data) => {
-     *   return await riskyOperation(data);
-     * });
-     * if (result instanceof ExecutorError) {
-     *   console.error('Task failed:', result);
-     * }
-     * ```
-     */
-    abstract execNoError<Result, Params = unknown>(task: Task<Result, Params>): Promise<Result | ExecutorError> | Result | ExecutorError;
-    /**
-     * Execute a task with input data without throwing errors
-     *
-     * - Purpose: Safe task execution with error wrapping and input data
-     * - Core Concept: Error-safe execution pipeline with data
-     * - Main Features:
-     *  - Error wrapping in ExecutorError
-     *  - Non-throwing execution
-     * - Primary Use: When error handling is preferred over exceptions with input data
-     *
-     * @param data - Input data for task
-     * @param task - Task to execute
-     *
-     * @example
-     * ```typescript
-     * const result = await executor.execNoError(data, async (data) => {
-     *   return await riskyOperation(data);
-     * });
-     * if (result instanceof ExecutorError) {
-     *   console.error('Task failed:', result);
-     * }
-     * ```
-     */
-    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];
-};
-
-export { Executor, ExecutorError, RequestError, RequestErrorID };
-export type { AsyncStorage, Encryptor, ExecutorContext, ExecutorPlugin, HookRuntimes, Intersection, PromiseTask, RequestAdapterConfig, RequestAdapterInterface, RequestAdapterResponse, RequestTransactionInterface, Serializer, SyncStorage, SyncTask, Task, ValueOf };