@qlover/fe-corekit 3.1.0 → 3.2.0

package/dist/index.d.ts

@@ -6848,6 +6848,16 @@ type RequestAdapterContext = ExecutorContextInterface<RequestAdapterConfig, unkn
  * ```
  */
 type RequestPluginConfig = HeaderInjectorConfig & {
+    /**
+     * Allow empty URL
+     *
+     * If set to `false`, an error will be thrown when both `url` and `baseURL` are empty.
+     * If set to `true` (default), the URL builder will attempt to build the URL even if they are empty.
+     *
+     * @since 3.1.0
+     * @default `true`
+     */
+    allowEmptyUrl?: boolean;
     requestDataSerializer?: (data: unknown, config: RequestAdapterConfig & Omit<RequestPluginConfig, 'requestDataSerializer'>) => unknown;
 };
 interface RequestPluginInnerConfig {
@@ -6947,6 +6957,17 @@ declare class RequestPlugin implements LifecyclePluginInterface<RequestAdapterCo
      * @override
      */
     onBefore(ctx: RequestAdapterContext): void;
+    protected startsWith(url: string, baseUrl: string): boolean;
+    /**
+     * Main request handler
+     *
+     * This is the core of the plugin. It merges default plugin configuration with request context configuration,
+     * processes request data, builds the URL, and injects headers.
+     *
+     * @param config - Request configuration
+     * @returns Merged configuration with processed data, built URL, and injected headers
+     */
+    mergeConfig(config: RequestAdapterConfig & RequestPluginConfig): RequestAdapterConfig & RequestPluginConfig;
     /**
      * Merge default plugin configuration with request context configuration
      *
@@ -6959,7 +6980,7 @@ declare class RequestPlugin implements LifecyclePluginInterface<RequestAdapterCo
      * @param contextConfig - Configuration from request context
      * @returns Merged configuration
      */
-    protected mergeConfig(contextConfig: RequestAdapterConfig): RequestAdapterConfig & RequestPluginConfig;
+    protected createConfig(contextConfig: RequestAdapterConfig): RequestAdapterConfig & RequestPluginConfig;
     /**
      * Build the URL from the request configuration
      *
@@ -6967,7 +6988,7 @@ declare class RequestPlugin implements LifecyclePluginInterface<RequestAdapterCo
      * @returns The built URL
      * @throws {Error} If the built URL is empty or invalid
      */
-    protected buildUrl(config: RequestAdapterConfig): string;
+    protected buildUrl(config: RequestAdapterConfig & RequestPluginConfig): string;
     /**
      * Inject default headers into request configuration
      *
@@ -7263,6 +7284,7 @@ declare class ResponsePlugin implements LifecyclePluginInterface<ResponsePluginC
      * ```
      */
     onSuccess(context: ResponsePluginContext): Promise<void>;
+    handleResponse(returnValue: unknown, config: ResponsePluginConfig & RequestAdapterConfig<unknown>): Promise<RequestAdapterResponse> | undefined;
     /**
      * Validate response status
      *
@@ -8615,493 +8637,274 @@ declare class Base64Serializer implements SerializerIneterface<string, string> {
 }
 
 /**
- * Interface representing an asynchronous storage mechanism.
+ * Asynchronous key-value storage interface.
+ *
+ * Core concept:
+ * Contract for a storage that performs I/O asynchronously. All methods return `Promise`s;
+ * use this when the backend is async (e.g. IndexedDB, remote storage, encrypted async APIs).
  *
- * @template Key - The type of keys used to identify stored values.
- * @template ValueType - The type of values stored, defaults to unknown.
+ * Main features:
+ * - Key-value access: `setItem` / `getItem` / `removeItem` by key, all async
+ * - Optional default on read: overload with `defaultValue` returns a fallback when key is missing
+ * - Bulk clear: `clear()` removes all entries and resolves when done
+ * - Optional parameters: generic `Opt` allows implementations to support expiry, scope, etc.
  *
- * @example
+ * When to use: Prefer this over sync `StorageInterface` when the underlying store is async
+ * or when you want to avoid blocking the main thread.
  *
+ * @template Key - Type of keys used to identify stored values.
+ * @template ValueType - Type of values stored and retrieved.
+ * @template Opt - Type of optional storage/retrieval options (e.g. expiry, scope).
+ *
+ * @example Basic usage
  * ```typescript
- * const storage: AsyncStorage<string, number> = ...;
+ * const storage: AsyncStorageInterface<string, number, void> = ...;
  * await storage.setItem('key', 123);
  * const value = await storage.getItem('key', 0);
+ * await storage.removeItem('key');
+ * await storage.clear();
  * ```
  *
+ * @example Without default (returns null when missing)
+ * ```typescript
+ * const value = await storage.getItem('key');
+ * if (value !== null) { ... }
+ * ```
  */
-interface AsyncStorageInterface<Key, ValueType = unknown> {
+interface AsyncStorageInterface<Key, ValueType, Opt> {
     /**
-     * The number of items stored.
-     */
-    readonly length: number;
-    /**
-     * Asynchronously stores a value with the specified key.
+     * Stores a value under the given key asynchronously.
+     *
+     * Overwrites any existing value for `key`. Resolves when the write has completed;
+     * rejections are implementation-defined (e.g. quota, I/O errors).
      *
-     * @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.
+     * @param key - Key to identify the stored value.
+     * @param value - Value to store. Serialization is implementation-defined.
+     * @param options - Optional parameters for this write (e.g. `maxAge`, `scope`). Type is `Opt`.
+     * @returns Promise that resolves when the value is stored, or rejects on failure.
      */
-    setItem<T>(key: Key, value: T, options?: unknown): Promise<void>;
+    setItem(key: Key, value: ValueType, options?: Opt): Promise<void>;
     /**
-     * Asynchronously retrieves a value by key.
+     * Retrieves the value for the given key asynchronously.
      *
-     * @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.
+     * Use this overload when the caller handles missing keys explicitly (e.g. with `null` check).
+     *
+     * @param key - Key of the value to retrieve.
+     * @param options - Optional parameters for retrieval. Type is `Opt`.
+     * @returns Promise resolving to the stored value, or `null` if the key does not exist.
      */
-    getItem<T extends ValueType>(key: Key, defaultValue?: T, options?: unknown): Promise<T | null>;
+    getItem(key: Key, options?: Opt): Promise<ValueType | null>;
     /**
-     * Asynchronously removes a value by key.
+     * Retrieves the value for the given key, or the default when missing.
+     *
+     * Use this overload when a fallback is required; the promise resolves to `ValueType` (never `null`).
      *
-     * @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.
+     * @param key - Key of the value to retrieve.
+     * @param defaultValue - Value to return when the key is not found.
+     * @param options - Optional parameters for retrieval. Type is `Opt`.
+     * @returns Promise resolving to the stored value if present, otherwise `defaultValue`.
      */
-    removeItem(key: Key, options?: unknown): Promise<void>;
+    getItem(key: Key, defaultValue: ValueType, options?: Opt): Promise<ValueType>;
     /**
-     * Asynchronously clears all stored values.
+     * Removes the entry for the given key asynchronously.
+     *
+     * No-op if the key does not exist. Resolves when the removal has completed.
      *
-     * @returns A promise that resolves when all values are cleared.
+     * @param key - Key of the value to remove.
+     * @param options - Optional parameters for removal. Type is `Opt`.
+     * @returns Promise that resolves when the value is removed (or when no-op completes).
      */
-    clear(): Promise<void>;
-}
-
-interface ExpireOptions {
+    removeItem(key: Key, options?: Opt): Promise<void>;
     /**
-     * Expire time
+     * Removes all entries in this storage asynchronously.
      *
-     * maybe is
-     * - number: milliseconds
-     * - string: time string, like '1d', '1h', '1m', '1s'
-     * - object: {}
-     * - ...
+     * Scope of "all" is implementation-defined. Resolves when the clear has completed.
      *
-     * Subclass implementation
+     * @returns Promise that resolves when all values are cleared.
      */
-    expires?: unknown;
+    clear(): Promise<void>;
 }
 
 /**
- * Key-value storage interface for managing a single value with persistence support
+ * Synchronous key-value storage interface.
  *
  * Core concept:
- * Provides a unified interface for storing and retrieving a single value associated
- * with a specific key. Supports both in-memory and persistent storage backends,
- * enabling flexible storage strategies for different use cases.
- *
- * **v2.3.0 before this was an abstract class, now it is an interface**
+ * Contract for a sync storage that maps keys to values. All operations complete immediately;
+ * suitable for in-memory stores, `localStorage`/`sessionStorage` adapters, or any backend
+ * that does not require async I/O.
  *
  * Main features:
- * - Single value storage: Store one value per key instance
- * - Key management: Retrieve the storage key associated with this instance
- * - Value retrieval: Get stored value from memory or persistent storage
- * - Value persistence: Save value to underlying storage backend
- * - Value removal: Clear value from both memory and persistent storage
- * - Options support: Flexible options parameter for storage-specific configurations
- *
- * Typical usage scenarios:
- * - Token storage: Store authentication tokens with persistence
- * - User info storage: Persist user information across sessions
- * - Configuration storage: Store application settings (theme, language, etc.)
- * - Session data: Manage temporary session-specific data
- *
- * Design decisions:
- * - Returns `null` when value is not found (explicit null handling)
- * - Options parameter is optional to support simple use cases
- * - Generic types allow type-safe storage of any value type
- * - Supports both synchronous and asynchronous storage backends through options
- *
- * @template Key - The type of the storage key (e.g., `string`, `number`, `symbol`)
- * @template Value - The type of value to store
- * @template Opt - The type of options for storage operations (defaults to `unknown`)
- *
- * @example Basic usage with localStorage
- * ```typescript
- * const tokenStorage: KeyStorageInterface<string, string> = new KeyStorage('token', {
- *   storage: localStorage
- * });
- *
- * // Store token
- * tokenStorage.set('abc123token');
+ * - Key-value access: `setItem` / `getItem` / `removeItem` by key
+ * - Optional default on read: second `getItem` overload returns a default when key is missing
+ * - Bulk clear: `clear()` removes all entries
+ * - Optional parameters: generic `Opt` allows implementations to support expiry, scope, etc.
  *
- * // Retrieve token
- * const token = tokenStorage.get(); // Returns 'abc123token'
+ * Design note: `getItem` returns `V | null` when no default is given, to align with the
+ * browser {@link Storage} API (e.g. `localStorage.getItem` returns `string | null`).
  *
- * // Get storage key
- * const key = tokenStorage.getKey(); // Returns 'token'
+ * @template K - Type of keys used to identify stored values.
+ * @template V - Type of values stored and retrieved.
+ * @template Opt - Type of optional storage/retrieval options (e.g. expiry, scope). Defaults to `unknown`.
  *
- * // Remove token
- * tokenStorage.remove();
- * ```
- *
- * @example User information storage
+ * @example Basic usage
  * ```typescript
- * interface User {
- *   id: string;
- *   name: string;
- *   email: string;
- * }
- *
- * const userStorage: KeyStorageInterface<string, User> = new KeyStorage('user', {
- *   storage: localStorage
- * });
- *
- * const user: User = {
- *   id: '123',
- *   name: 'John Doe',
- *   email: 'john@example.com'
- * };
- *
- * userStorage.set(user);
- * const storedUser = userStorage.get(); // Returns User object
+ * const storage: StorageInterface<string, number> = ...;
+ * storage.setItem('count', 42);
+ * const value = storage.getItem('count', 0) ?? 0;
+ * storage.removeItem('count');
+ * storage.clear();
  * ```
  *
- * @example With custom options
+ * @example With options (e.g. expiry)
  * ```typescript
- * interface StorageOptions {
- *   encrypt?: boolean;
- *   expires?: number;
- * }
- *
- * const secureStorage: KeyStorageInterface<string, string, StorageOptions> =
- *   new KeyStorage('secret', {
- *     storage: localStorage,
- *     encrypt: true
- *   });
- *
- * secureStorage.set('sensitive-data', { encrypt: true, expires: 3600 });
+ * storage.setItem('token', 'abc', { maxAge: 3600 });
+ * const token = storage.getItem('token', { scope: 'session' });
  * ```
  */
-interface KeyStorageInterface<Key, Value, Opt = unknown> {
+interface StorageInterface<K, V, Opt = unknown> {
     /**
-     * Get the storage key associated with this instance
+     * Stores a value under the given key.
      *
-     * Returns the key that was used to initialize this storage instance.
-     * This key is used to identify the storage location in the underlying
-     * storage backend.
+     * Overwrites any existing value for `key`. Implementations may use `options` for
+     * behaviour such as TTL or storage scope.
      *
-     * @returns The storage key of type `Key`
-     *
-     * @example
-     * ```typescript
-     * const storage = new KeyStorage('my-key', { storage: localStorage });
-     * const key = storage.getKey(); // Returns 'my-key'
-     * ```
+     * @param key - Key to identify the stored value. Must be valid for the underlying store.
+     * @param value - Value to store. Serialization is implementation-defined (e.g. JSON, string-only).
+     * @param options - Optional parameters for this write (e.g. `maxAge`, `scope`). Type is `Opt`.
      */
-    getKey(): Key;
+    setItem(key: K, value: V, options?: Opt): void;
     /**
-     * Get the current in-memory value without accessing persistent storage
-     *
-     * Returns the value currently stored in memory. This method does not
-     * attempt to load from persistent storage. Use `get()` if you want
-     * to retrieve from persistent storage when memory value is null.
-     *
-     * Returns `null` if:
-     * - No value has been set yet
-     * - Value was removed via `remove()`
-     * - Value was never loaded from storage
-     *
-     * @returns The current in-memory value, or `null` if not available
-     *
-     * @example
-     * ```typescript
-     * const storage = new KeyStorage('token', { storage: localStorage });
-     *
-     * // Initially null (not loaded from storage yet)
-     * const memValue = storage.getValue(); // Returns null
+     * Retrieves the value for the given key.
      *
-     * // After setting
-     * storage.set('abc123');
-     * const memValue2 = storage.getValue(); // Returns 'abc123'
+     * Returns `null` when the key is not found, so the signature stays compatible with the
+     * browser {@link Storage} API.
      *
-     * // After removal
-     * storage.remove();
-     * const memValue3 = storage.getValue(); // Returns null
-     * ```
+     * @param key - Key of the value to retrieve.
+     * @param options - Optional parameters for retrieval (e.g. scope). Type is `Opt`.
+     * @returns The stored value, or `null` if the key does not exist.
      */
-    getValue(): Value | null;
+    getItem(key: K, options?: Opt): V | null;
     /**
-     * Retrieve value from storage with optional configuration
-     *
-     * Retrieval strategy:
-     * 1. First checks in-memory value (fast path)
-     * 2. If memory value is null and persistent storage is available,
-     *    loads from persistent storage and updates memory cache
-     * 3. Returns null if value doesn't exist in either location
+     * Retrieves the value for the given key, or the default when missing.
      *
-     * The `options` parameter allows passing storage-specific configuration
-     * that may override default behavior (e.g., encryption settings, expiration checks).
+     * Use this overload when a fallback is required so callers avoid explicit `null` checks.
      *
-     * @param options - Optional storage operation configuration
-     * @returns The stored value, or `null` if not found
-     *
-     * @example Basic retrieval
-     * ```typescript
-     * const storage = new KeyStorage('token', { storage: localStorage });
-     * storage.set('abc123');
-     * const token = storage.get(); // Returns 'abc123'
-     * ```
-     *
-     * @example With options
-     * ```typescript
-     * interface Options {
-     *   decrypt?: boolean;
-     * }
-     *
-     * const storage = new KeyStorage<string, string, Options>('secret', {
-     *   storage: localStorage
-     * });
-     *
-     * // Retrieve with decryption
-     * const value = storage.get({ decrypt: true });
-     * ```
-     *
-     * @example Handling null values
-     * ```typescript
-     * const storage = new KeyStorage('data', { storage: localStorage });
-     * const value = storage.get();
-     *
-     * if (value === null) {
-     *   console.log('No value stored');
-     * } else {
-     *   console.log('Value:', value);
-     * }
-     * ```
+     * @param key - Key of the value to retrieve.
+     * @param defaultValue - Value to return when the key is not found.
+     * @param options - Optional parameters for retrieval. Type is `Opt`.
+     * @returns The stored value if present, otherwise `defaultValue`.
      */
-    get(options?: Opt): Value | null;
+    getItem(key: K, defaultValue: V, options?: Opt): V | null;
     /**
-     * Store a value with optional configuration
-     *
-     * Storage behavior:
-     * - Updates in-memory value immediately
-     * - Persists to underlying storage backend if available
-     * - Merges provided options with default options
-     * - Overwrites any existing value for this key
-     *
-     * The `options` parameter can be used to pass storage-specific settings
-     * such as encryption, expiration, or other backend-specific configurations.
-     *
-     * @param value - The value to store (can be any type matching `Value`)
-     * @param options - Optional storage operation configuration
-     *
-     * @example Basic storage
-     * ```typescript
-     * const storage = new KeyStorage('token', { storage: localStorage });
-     * storage.set('abc123token');
-     * ```
-     *
-     * @example Storing complex objects
-     * ```typescript
-     * interface User {
-     *   id: string;
-     *   name: string;
-     * }
-     *
-     * const storage = new KeyStorage<string, User>('user', {
-     *   storage: localStorage
-     * });
-     *
-     * storage.set({
-     *   id: '123',
-     *   name: 'John Doe'
-     * });
-     * ```
+     * Removes the entry for the given key.
      *
-     * @example With encryption options
-     * ```typescript
-     * interface Options {
-     *   encrypt?: boolean;
-     *   expires?: number;
-     * }
+     * No-op if the key does not exist. Implementations may use `options` (e.g. scope) to
+     * target a specific storage area.
      *
-     * const storage = new KeyStorage<string, string, Options>('secret', {
-     *   storage: localStorage
-     * });
-     *
-     * storage.set('sensitive-data', {
-     *   encrypt: true,
-     *   expires: Date.now() + 3600000 // 1 hour
-     * });
-     * ```
+     * @param key - Key of the value to remove.
+     * @param options - Optional parameters for removal. Type is `Opt`.
      */
-    set(value: Value, options?: Opt): void;
+    removeItem(key: K, options?: Opt): void;
     /**
-     * Remove the stored value from both memory and persistent storage
-     *
-     * Removal behavior:
-     * - Clears in-memory value (sets to `null`)
-     * - Removes value from persistent storage backend if available
-     * - Applies any options-specific removal behavior
-     *
-     * After calling `remove()`, subsequent calls to `get()` will return `null`
-     * until a new value is set via `set()`.
-     *
-     * @param options - Optional storage operation configuration
-     *
-     * @example Basic removal
-     * ```typescript
-     * const storage = new KeyStorage('token', { storage: localStorage });
-     * storage.set('abc123');
-     * storage.remove(); // Removes from both memory and localStorage
-     * const token = storage.get(); // Returns null
-     * ```
-     *
-     * @example With options
-     * ```typescript
-     * interface Options {
-     *   softDelete?: boolean;
-     * }
-     *
-     * const storage = new KeyStorage<string, string, Options>('data', {
-     *   storage: localStorage
-     * });
-     *
-     * // Remove with soft delete option
-     * storage.remove({ softDelete: true });
-     * ```
-     *
-     * @example Clearing user session
-     * ```typescript
-     * const userStorage = new KeyStorage('user', { storage: localStorage });
+     * Removes all entries in this storage.
      *
-     * // User logs out
-     * userStorage.remove();
-     * ```
+     * Scope of "all" is implementation-defined (e.g. may be limited to a prefix or namespace).
      */
-    remove(options?: Opt): void;
+    clear(): void;
 }
 
 /**
- * Interface representing a synchronous storage mechanism.
+ * Storage interface bound to a single fixed key.
  *
- * @template Key - The type of keys used to identify stored values.
- * @template ValueType - The type of values stored, defaults to unknown.
+ * Core concept:
+ * A storage abstraction that only ever reads/writes one key, exposed as `key`. Callers use
+ * `get`/`set`/`remove` without passing a key; useful for token storage, single preference,
+ * or any "one value per instance" scenario.
  *
- * @example
+ * Main features:
+ * - Fixed key: `readonly key` identifies the sole key this instance operates on
+ * - Simple API: `get()` / `set(value)` / `remove()` with no key argument
+ * - Optional parameters: generic `Opt` allows implementations to support expiry, scope, etc.
+ *
+ * When to use: Prefer this over a generic key-value interface when the semantic is "one
+ * named slot" (e.g. auth token, theme, locale) and you want to avoid key typos and keep
+ * API minimal.
+ *
+ * @template Key - Type of the fixed key (e.g. string literal `'token'` or union of known keys).
+ * @template Value - Type of the value stored and retrieved.
+ * @template Opt - Type of optional storage/retrieval options. Defaults to `unknown`.
+ *
+ * @example Basic usage (token)
  * ```typescript
- * const storage: SyncStorage<string, number> = ...;
- * storage.setItem('key', 123);
- * const value = storage.getItem('key', 0);
+ * const tokenStorage: KeyStorageInterface<'token', string> = ...;
+ * tokenStorage.set('jwt-abc');
+ * const token = tokenStorage.get();
+ * tokenStorage.remove();
+ * ```
+ *
+ * @example With options
+ * ```typescript
+ * tokenStorage.set('jwt-abc', { maxAge: 3600 });
+ * const token = tokenStorage.get({ scope: 'session' });
  * ```
  */
-interface SyncStorageInterface<Key, Opt = unknown> {
-    /**
-     * The number of items stored.
-     */
-    readonly length: number;
+interface KeyStorageInterface<Key, Value, Opt = unknown> {
     /**
-     * Stores a value with the specified key.
+     * The single key this storage instance is bound to.
      *
-     * @param key - The key to identify the stored value.
-     * @param value - The value to store.
-     * @param options - Optional parameters for storage.
+     * All `get`/`set`/`remove` operations act on this key. Read-only so that the binding
+     * cannot change after creation.
      */
-    setItem<T>(key: Key, value: T, options?: Opt): void | unknown;
+    readonly key: Key;
     /**
-     * Retrieves a value by key.
+     * Reads the value for the bound 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.
+     * @param options - Optional parameters for retrieval (e.g. scope). Type is `Opt`.
+     * @returns The stored value, or `null` if no value has been set or it was removed.
      */
-    getItem<T>(key: Key, defaultValue?: T, options?: Opt): T | null;
+    get(options?: Opt): Value | null;
     /**
-     * Removes a value by key.
+     * Writes the value for the bound key.
      *
-     * @param key - The key of the value to remove.
-     * @param options - Optional parameters for removal.
-     */
-    removeItem(key: Key, options?: Opt): void;
-    /**
-     * Clears all stored values.
+     * Overwrites any existing value. Implementations may use `options` for behaviour such
+     * as TTL or storage scope.
+     *
+     * @param value - Value to store. Serialization is implementation-defined.
+     * @param options - Optional parameters for this write (e.g. `maxAge`, `scope`). Type is `Opt`.
      */
-    clear(): void;
+    set(value: Value, options?: Opt): void;
     /**
-     * Get the raw value from the storage.
+     * Removes the value for the bound key.
      *
-     * 通过这个方法可以获取到内部原始的值
+     * No-op if the key is already absent. Implementations may use `options` (e.g. scope)
+     * to target a specific storage area.
      *
-     * @param value - The value to get the raw value from.
-     * @returns The raw value.
+     * @param options - Optional parameters for removal. Type is `Opt`.
      */
-    getRawValue?<T>(value: unknown, defaultValue?: T, options?: Opt): T | null;
+    remove(options?: Opt): void;
 }
 
-interface KeyStorageOptions<Key, Sopt = unknown> extends ExpireOptions {
-    /**
-     * Persistent storage
-     */
-    storage?: SyncStorageInterface<Key, Sopt>;
-}
-/**
- * KeyStorage is a storage that can be used to store a single value.
- *
- * Typical usage scenario: need to store a value and need to persist it:
- *
- * - token storage
- * - user info storage
- * - page theme, language
- * - ...
- *
- * And support for data encryption, there are times when reporting errors in the local data can easily be tampered with, this time you can use encryption to protect the data!
- *
- * @since 1.5.0
- *
- * @example basic usage
- *
- * use localStorage as storage, persist the value
- *
- * ```typescript
- * const tokenStorage = new KeyStorage('token', localStorage);
- *
- * tokenStorage.get(); // get from localStorage
- * tokenStorage.set('token-123123123'); // set to localStorage
- * tokenStorage.remove(); // remove from localStorage
- * ```
- *
- * @example with encrypt
- * ```typescript
- * const tokenStorage = new KeyStorage('token', localStorage, {
- *   encrypt: new Encryptor(new AESCipher('1234567890'))
- * });
- *
- * tokenStorage.get(); // get from localStorage
- * tokenStorage.set('token-123123123'); // set to localStorage
- * tokenStorage.remove(); // remove from localStorage
- * ```
- */
-declare class KeyStorage<Key, Value, Opt extends KeyStorageOptions<Key> = KeyStorageOptions<Key>> implements KeyStorageInterface<Key, Value, Opt> {
-    readonly key: Key;
-    protected options: Opt;
-    protected value: Value | null;
-    constructor(key: Key, options?: Opt);
-    protected mergeOptions(options?: Opt): Opt;
-    /**
-     * @override
-     */
-    getKey(): Key;
-    /**
-     * @override
-     */
-    getValue(): Value | null;
+declare class KeyStorage<K, V, Opt = unknown> implements KeyStorageInterface<K, V, Opt> {
+    readonly key: K;
+    protected readonly storage?: StorageInterface<K, V, Opt> | undefined;
+    protected value: V | undefined | null;
+    constructor(key: K, storage?: StorageInterface<K, V, Opt> | undefined);
     /**
      * @override
      */
-    get(options?: Opt): Value | null;
+    get(options?: Opt): V | null;
     /**
      * @override
      */
-    set(token: Value, options?: Opt): void;
+    set(value: V, options?: Opt): void;
     /**
      * @override
      */
     remove(options?: Opt): void;
 }
 
-interface ObjectStorageOptions extends ExpireOptions {
+interface ObjectStorageOptions {
+    expires?: number;
 }
 /**
  * Storage value wrapper with expiration support
@@ -9169,7 +8972,7 @@ type StorageValue<Key, ValueType> = {
  *
  * @since 1.5.0
  */
-declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOptions = ObjectStorageOptions> implements SyncStorageInterface<Key, Opt> {
+declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOptions = ObjectStorageOptions> implements StorageInterface<Key, ValueType, Opt> {
     /**
      * Serializer for data transformation
      *
@@ -9178,7 +8981,7 @@ declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOp
      * Main function: Serialize/deserialize storage values
      * Main purpose: Support type-safe storage operations
      */
-    protected readonly serializer?: SerializerIneterface<unknown, ValueType> | undefined;
+    protected readonly serializer?: SerializerIneterface<ValueType, string> | undefined;
     /**
      * In-memory storage map for fast data access
      *
@@ -9211,11 +9014,10 @@ declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOp
      * Main function: Serialize/deserialize storage values
      * Main purpose: Support type-safe storage operations
      */
-    serializer?: SerializerIneterface<unknown, ValueType> | undefined);
+    serializer?: SerializerIneterface<ValueType, string> | undefined);
     /**
      * Gets the number of items stored in the memory cache
      *
-     * @override
      * @returns The number of stored items in memory
      *
      * @example
@@ -9247,7 +9049,7 @@ declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOp
      * storage.setItem('session', sessionData, Date.now() + 3600000);
      * ```
      */
-    setItem<T>(key: Key, value: T, options?: ObjectStorageOptions): unknown;
+    setItem<T>(key: Key, value: T, options?: ObjectStorageOptions): ValueType;
     /**
      * Retrieves a stored value by key with fallback strategy
      *
@@ -9277,11 +9079,8 @@ declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOp
      * const config = storage.getItem<AppConfig>('app-config');
      * ```
      */
-    getItem<T>(key: Key, defaultValue?: T): T | null;
-    /**
-     * @override
-     */
-    getRawValue<T>(value: unknown, defaultValue?: T): T | null;
+    getItem(key: Key, defaultValue?: unknown): ValueType | null;
+    protected getRawValue<T>(value: unknown, defaultValue?: T): T | null;
     /**
      * Removes a stored item by its key from both memory and persistent storage
      *
@@ -9357,339 +9156,194 @@ declare class ObjectStorage<Key, ValueType = string, Opt extends ObjectStorageOp
      * ```
      */
     protected isStorageValue(value: unknown): value is StorageValue<Key, ValueType>;
+}
+
+/**
+ * Plugin contract for the storage pipeline.
+ *
+ * Each plugin participates in a chain: on `set`, value flows forward (e.g. serialize → encrypt → persist);
+ * on `get`, value flows backward (e.g. read → decrypt → deserialize). The second argument to `get` is
+ * the value produced by the previous plugin in the chain so each step can transform it.
+ *
+ * @template K - Key type
+ * @template V - Value type
+ * @template Opt - Options type passed through the chain
+ */
+interface StorageExecutorPlugin<K, V, Opt> {
     /**
-     * Gets the serializer instance
+     * Transform or read value in the get pipeline. Receives `valueFromPrevious` from the next plugin
+     * in the chain (e.g. raw string from storage, then decrypted, then deserialized).
      *
-     * Significance: Provides access to the serialization logic
-     * Core idea: Expose serializer for advanced use cases
-     * Main function: Return the serializer instance
-     * Main purpose: Enable direct access to serialization when needed
+     * @param key - Storage key
+     * @param valueFromPrevious - Value from the previous step in the reverse chain; first call gets `defaultValue`
+     * @param options - Optional options forwarded to the chain
+     * @returns Transformed value, or `undefined` to keep current pipeline value
+     */
+    get(key: K, valueFromPrevious: unknown, options?: Opt): V | undefined | null;
+    /**
+     * Transform or persist value in the set pipeline. May return the transformed value for the next plugin.
      *
-     * @returns The serializer instance
+     * @param key - Storage key
+     * @param value - Value from the previous step (or initial value)
+     * @param options - Optional options forwarded to the chain
+     * @returns Transformed value for the next plugin, or `undefined` if this step does not change the value
+     */
+    set(key: K, value: V, options?: Opt): unknown;
+    /** Optional: remove item for this key. Only storage plugins typically implement this. */
+    remove?(key?: K, options?: Opt): void;
+    /** Optional: clear all data. Only storage plugins typically implement this. */
+    clear?(): void;
+    /**
+     * When `'storage'`, this plugin reads from a backing store. On `getItem`, once the first
+     * storage (from tail) returns a value, no further storage plugins are used for get; only
+     * `'pipe'` plugins keep transforming the value. When `'pipe'` or omitted, the plugin only
+     * transforms (e.g. serialize, encrypt).
+     *
+     * @example type=storage use first storage
      *
-     * @example
      * ```typescript
-     * const serializer = storage.getSerializer();
-     * if (serializer) {
-     *   // Direct access to serializer
-     * }
+     * const executor = new StorageExecutor([jsonSerializer, aesEncryptor, sessionStorage, localStorage]);
+     * executor.setItem('key', { a: 1 }); // { a: 1 } → serialize → encrypt → sessionStorage → localStorage
+     * executor.getItem('key'); // localStorage → decrypt → deserialize → { a: 1 }
      * ```
      */
-    getSerializer(): SerializerIneterface<unknown, ValueType> | undefined;
+    type?: 'storage' | string;
 }
-
 /**
- * Pipe processor type definition
+ * Executes a pipeline of storage plugins, implementing `StorageInterface`.
  *
- * Significance: Define the type of components that can be used for data processing pipelines
- * Core idea: Unify the type definition of different processors, supporting data transformation and intermediate storage
- * Main function: Provide type-safe pipeline components
- * Main purpose: Support serialization, encryption, intermediate storage, and other data processing operations
- */
-type PipeType<Key> = SerializerIneterface<unknown, unknown> | EncryptorInterface<unknown, unknown> | SyncStorageInterface<Key, unknown>;
-/**
- * Pipe value definition, containing the pipe processor and its type identifier
- *
- * Significance: Pre-determine the pipe type to avoid runtime type checks
- * Core idea: Bind the pipe processor with its type to improve execution efficiency
- * Main function: Store the pipe processor and its type information
- * Main purpose: Optimize pipe execution performance, simplify type judgment logic
- */
-type PipeValue<Key> = {
-    type: 'serialize';
-    pipe: SerializerIneterface<unknown, unknown>;
-} | {
-    type: 'encrypt';
-    pipe: EncryptorInterface<unknown, unknown>;
-} | {
-    type: 'storage';
-    pipe: SyncStorageInterface<Key, unknown>;
-};
-
-/**
- * Pipe argument type for storage initialization
- *
- * Accepts either a typed pipe or a pipe value wrapper.
- *
- * @template Key - Type of storage keys
- */
-type PipeArg<Key> = PipeType<Key> | PipeValue<Key>;
-/**
- * Synchronous storage implementation with pipeline support
- *
- * Core concept:
- * Provides a flexible storage abstraction with a pipeline architecture that
- * allows chaining multiple transformations (serialization, encryption, intermediate
- * storage) before data reaches the final storage backend.
+ * Core concept: values flow through plugins in order on `set` (e.g. serialize → encrypt → storage),
+ * and in reverse order on `get` (storage → decrypt → deserialize). Each plugin receives the value
+ * from the previous step and may return a transformed value for the next.
  *
  * Main features:
- * - Pipeline architecture: Chain multiple data transformations
- *   - Serialization: Convert objects to strings (JSON, Base64, etc.)
- *   - Encryption: Secure data before storage
- *   - Intermediate storage: Multi-layer storage support
- *   - Custom transformations: Extensible pipe system
- *
- * - Automatic pipe detection: Identifies pipe types by interface
- *   - Serializer: Has `serialize()` and `deserialize()` methods
- *   - Encryptor: Has `encrypt()` and `decrypt()` methods
- *   - Storage: Has `setItem()`, `getItem()`, `removeItem()`, `clear()` methods
- *   - No manual type specification needed
- *
- * - Bidirectional processing: Handles both storage and retrieval
- *   - setItem: Forward pipeline (value → serialize → encrypt → store)
- *   - getItem: Reverse pipeline (retrieve → decrypt → deserialize → value)
- *   - Maintains data integrity through the pipeline
- *
- * - Multi-layer storage: Support for intermediate storage layers
- *   - Primary storage: Final storage backend
- *   - Intermediate storage: Additional storage layers in pipeline
- *   - Fallback mechanism: Try intermediate storage if primary fails
- *
- * Pipeline execution order:
- *
- * **setItem (forward):**
- * 1. Original value
- * 2. Serialize (if serializer in pipeline)
- * 3. Encrypt (if encryptor in pipeline)
- * 4. Store in intermediate storage (if storage in pipeline)
- * 5. Store in primary storage
- *
- * **getItem (reverse):**
- * 1. Retrieve from primary storage
- * 2. If not found, try intermediate storage layers (reversed order)
- * 3. Decrypt (if encryptor in pipeline)
- * 4. Deserialize (if serializer in pipeline)
- * 5. Return final value
- *
- * @template Key - Type of storage keys (typically `string`)
- * @template Opt - Type of storage options (optional)
- *
- * @example Basic usage with JSON serialization
- * ```typescript
- * import { SyncStorage, JSONSerializer } from '@qlover/fe-corekit';
- *
- * const storage = new SyncStorage(
- *   localStorage,
- *   new JSONSerializer()
- * );
+ * - **setItem**: Iterates plugins forward; each `set` may return a new value (e.g. serialized/encrypted) for the next
+ * - **getItem**: Iterates plugins backward. **When there are multiple storage plugins, only the value from the
+ *   last storage (the one at the end of the plugin array) is used for reading; all other storage plugins are
+ *   skipped and their values are ignored.** Pipe plugins (serializer, encryptor, etc.) still transform the
+ *   value as usual.
+ * - **removeItem** / **clear**: Delegated to all plugins that implement `remove` / `clear`
  *
- * // Store object (automatically serialized to JSON)
- * storage.setItem('user', { id: 1, name: 'John' });
+ * @template K - Key type
+ * @template V - Value type (after serialization/encryption may differ internally)
+ * @template Opt - Options type
  *
- * // Retrieve object (automatically deserialized from JSON)
- * const user = storage.getItem('user');
- * console.log(user); // { id: 1, name: 'John' }
- * ```
- *
- * @example With encryption
+ * @example Single storage backend
  * ```typescript
- * import { SyncStorage, JSONSerializer, AESEncryptor } from '@qlover/fe-corekit';
- *
- * const storage = new SyncStorage(
- *   localStorage,
- *   [
- *     new JSONSerializer(),     // First: serialize to JSON
- *     new AESEncryptor('key')   // Then: encrypt JSON string
- *   ]
- * );
- *
- * // Data is serialized then encrypted before storage
- * storage.setItem('sensitive', { password: 'secret' });
- *
- * // Data is decrypted then deserialized on retrieval
- * const data = storage.getItem('sensitive');
+ * const executor = new StorageExecutor(localStorage);
+ * executor.setItem('key', { a: 1 });
+ * executor.getItem('key');
  * ```
  *
- * @example Multi-layer storage
+ * @example Pipeline: serializer + encryptor + storage
  * ```typescript
- * import { SyncStorage, JSONSerializer } from '@qlover/fe-corekit';
- *
- * // Create intermediate storage layer
- * const memoryCache = new Map();
- * const cacheStorage = {
- *   setItem: (k, v) => memoryCache.set(k, v),
- *   getItem: (k) => memoryCache.get(k) ?? null,
- *   removeItem: (k) => memoryCache.delete(k),
- *   clear: () => memoryCache.clear(),
- *   length: memoryCache.size
- * };
- *
- * const storage = new SyncStorage(
- *   localStorage,
- *   [
- *     new JSONSerializer(),
- *     cacheStorage  // Intermediate cache layer
- *   ]
- * );
- *
- * // Data stored in both cache and localStorage
- * storage.setItem('data', { value: 123 });
- *
- * // Retrieval tries cache first, then localStorage
- * const data = storage.getItem('data');
+ * const executor = new StorageExecutor([jsonSerializer, aesEncryptor, localStorage]);
+ * executor.setItem('key', obj);  // obj → serialize → encrypt → persist
+ * executor.getItem('key');       // read → decrypt → deserialize → obj
  * ```
  *
- * @example Custom pipe order
+ * @example Multiple storages: getItem uses only the last storage
  * ```typescript
- * // Order matters! Pipes are applied in sequence
- * const storage = new SyncStorage(
- *   localStorage,
- *   [
- *     new JSONSerializer(),     // 1. Serialize to JSON string
- *     new Base64Serializer(),   // 2. Encode to Base64
- *     new AESEncryptor('key')   // 3. Encrypt the Base64 string
- *   ]
- * );
- *
- * // setItem: value → JSON → Base64 → Encrypt → store
- * // getItem: retrieve → Decrypt → Base64 decode → JSON parse → value
+ * const executor = new StorageExecutor([sessionStorage, localStorage]);
+ * executor.setItem('key', 'v');           // writes to both
+ * executor.getItem('key');                 // reads only from localStorage (last); sessionStorage is ignored
  * ```
- *
- * @see {@link SyncStorageInterface} for the storage interface
- * @see {@link PipeType} for pipe type definitions
- * @see {@link SerializerInterface} for serializer interface
- * @see {@link EncryptorInterface} for encryptor interface
  */
-declare class SyncStorage<Key, Opt = unknown> implements SyncStorageInterface<Key, Opt> {
-    protected readonly storage: SyncStorageInterface<Key, Opt>;
-    /**
-     * Internal pipe value list with pre-determined types
-     *
-     * Stores the processed pipeline of transformations that will be
-     * applied to data during storage and retrieval operations.
-     *
-     * @protected
-     */
-    protected readonly pipes: PipeValue<Key>[];
-    /**
-     * Creates a new SyncStorage instance with pipeline support
-     *
-     * @param storage - Primary storage backend (e.g., localStorage, sessionStorage)
-     * @param pipes - Optional pipe or array of pipes for data transformation
-     *
-     * @example Single pipe
-     * ```typescript
-     * const storage = new SyncStorage(
-     *   localStorage,
-     *   new JSONSerializer()
-     * );
-     * ```
-     *
-     * @example Multiple pipes
-     * ```typescript
-     * const storage = new SyncStorage(
-     *   localStorage,
-     *   [
-     *     new JSONSerializer(),
-     *     new AESEncryptor('secret-key')
-     *   ]
-     * );
-     * ```
-     *
-     * @example No pipes (direct storage)
-     * ```typescript
-     * const storage = new SyncStorage(localStorage);
-     * // Data stored as-is without transformation
-     * ```
-     */
-    constructor(storage: SyncStorageInterface<Key, Opt>, pipes?: PipeArg<Key>[] | PipeArg<Key>);
+declare class StorageExecutor<K, V, Opt = unknown> implements StorageInterface<K, V, Opt> {
+    protected plugins: StorageExecutorPlugin<K, V, Opt>[];
     /**
-     * Get the number of items in the primary storage
+     * Builds the plugin list from either a single `StorageInterface` or an array whose last element
+     * is the backing storage and preceding elements are transformers (e.g. serializer, encryptor).
      *
-     * Returns the count of items in the primary storage backend only.
-     * Does not include items in intermediate storage layers.
-     *
-     * @override
-     * @returns Number of items in primary storage
-     *
-     * @example
-     * ```typescript
-     * console.log(storage.length); // 5
-     * storage.setItem('newKey', 'value');
-     * console.log(storage.length); // 6
-     * ```
+     * @param plugins - Single storage instance or tuple of `[ ...transformers, storage ]`
      */
-    get length(): number;
+    constructor(plugins: StorageInterface<K, V, Opt> | [
+        ...(SerializerIneterface<V> | StorageInterface<K, V, Opt> | EncryptorInterface<V, unknown> | StorageExecutorPlugin<K, V, Opt>)[],
+        StorageInterface<K, V, Opt>
+    ]);
     /**
-     * Store a value with pipeline processing
-     *
-     * Processes the value through the configured pipeline (serialization,
-     * encryption, intermediate storage) before storing in the primary storage.
-     *
-     * Pipeline execution:
-     * 1. Apply serialization (if configured)
-     * 2. Apply encryption (if configured)
-     * 3. Store in intermediate storage layers (if configured)
-     * 4. Store in primary storage
+     * Writes value through the plugin chain (forward). Each plugin may return a transformed value for the next.
      *
      * @override
-     * @template T - Type of value to store
-     * @param key - Storage key
-     * @param value - Value to store
-     * @param options - Optional storage options (e.g., expiration)
-     *
-     * @example Basic storage
-     * ```typescript
-     * storage.setItem('user', { id: 1, name: 'John' });
-     * ```
-     *
-     * @example With options
-     * ```typescript
-     * storage.setItem('session', { token: 'abc' }, { expire: 3600 });
-     * ```
      */
-    setItem<T>(key: Key, value: T, options?: Opt): void;
+    setItem(key: K, value: V, options?: Opt | undefined): void;
+    /** @override */
+    getItem(key: K, options?: Opt | undefined): V | null;
+    /** @override */
+    getItem(key: K, defaultValue: V, options?: Opt | undefined): V;
     /**
-     * Retrieve a value with pipeline processing
-     *
-     * Retrieves the value from storage and processes it through the pipeline
-     * in reverse order (decryption, deserialization) to restore the original value.
-     *
-     * Retrieval strategy:
-     * 1. Try to retrieve from primary storage
-     * 2. If not found, try intermediate storage layers (in reverse order)
-     * 3. Apply decryption (if configured)
-     * 4. Apply deserialization (if configured)
-     * 5. Return processed value or default
+     * Removes item for the given key from all plugins that implement `remove`.
      *
      * @override
-     * @template T - Type of value to retrieve
-     * @param key - Storage key
-     * @param defaultValue - Default value if key not found
-     * @param options - Optional retrieval options
-     * @returns Retrieved value or default, `null` if not found and no default
-     *
-     * @example Basic retrieval
-     * ```typescript
-     * const user = storage.getItem('user');
-     * if (user) {
-     *   console.log(user.name);
-     * }
-     * ```
-     *
-     * @example With default value
-     * ```typescript
-     * const config = storage.getItem('config', { theme: 'light' });
-     * console.log(config.theme); // 'light' if not found
-     * ```
      */
-    getItem<T>(key: Key, defaultValue?: T, options?: Opt): T | null;
+    removeItem(key: K, options?: Opt | undefined): void;
     /**
-     * Delete data items, delete from all storage layers
+     * Clears data in all plugins that implement `clear`.
      *
      * @override
-     * @param key - Storage key
-     * @param options - Delete options
      */
-    removeItem(key: Key, options?: Opt): void;
-    /**
-     * Clear all data, including storage in the pipeline
-  
-     * @override
-        */
     clear(): void;
 }
 
+/**
+ * Wraps a `StorageInterface` as a `StorageExecutorPlugin` so it can participate in the pipeline.
+ * Forwards `get`/`set`/`remove`/`clear` to the underlying storage.
+ *
+ * @template K - Key type
+ * @template V - Value type
+ * @template Opt - Options type
+ * @param storage - The backing storage implementation
+ * @returns A plugin that delegates to `storage`
+ */
+declare function createStoragePluginWithStorage<K, V, Opt = unknown>(storage: StorageInterface<K, V, Opt>): StorageExecutorPlugin<K, V, Opt>;
+/**
+ * Type guard: checks if the value is a serializer (has `serialize` and `deserialize` methods).
+ *
+ * @template V - Value type the serializer handles
+ * @param plugin - Value to check
+ * @returns `true` if `plugin` implements `SerializerIneterface<V>`
+ */
+declare function isSerializer<V>(plugin: unknown): plugin is SerializerIneterface<V>;
+/**
+ * Type guard: checks if the value is an encryptor (has `encrypt` and `decrypt` methods).
+ *
+ * @template V - Value type the encryptor handles
+ * @template E - Encrypted result type
+ * @param plugin - Value to check
+ * @returns `true` if `plugin` implements `EncryptorInterface<V, E>`
+ */
+declare function isEncryptor<V, E>(plugin: unknown): plugin is EncryptorInterface<V, E>;
+/**
+ * Normalizes plugin input into an array of `StorageExecutorPlugin`.
+ *
+ * - If a single `StorageInterface` is passed, returns one plugin that wraps it.
+ * - If an array is passed, maps each element: serializers and encryptors are adapted so that
+ *   only the pipeline value is passed to `serialize`/`deserialize`/`encrypt`/`decrypt`; storage
+ *   instances are wrapped; other values are treated as already-implemented plugins. Array order
+ *   is preserved (first plugin = first in set chain, last = storage in typical usage).
+ *
+ * @template K - Key type
+ * @template V - Value type
+ * @template Opt - Options type
+ * @param plugins - Single storage or tuple `[ ...transformers, storage ]`
+ * @returns Array of plugins in pipeline order
+ *
+ * @example
+ * ```typescript
+ * createStoragePlugin(localStorage);
+ * // => [ wrap(localStorage) ]
+ *
+ * createStoragePlugin([jsonSerializer, encryptor, localStorage]);
+ * // => [ adapter(serialize/deserialize), adapter(encrypt/decrypt), wrap(localStorage) ]
+ * ```
+ */
+declare function createStoragePlugin<K, V, Opt = unknown>(plugins: StorageInterface<K, V, Opt> | [
+    ...(SerializerIneterface<V> | StorageInterface<K, V, Opt> | EncryptorInterface<V, unknown> | StorageExecutorPlugin<K, V, Opt>)[],
+    StorageInterface<K, V, Opt>
+]): StorageExecutorPlugin<K, V, Opt>[];
+
+declare function isStorage<Key, Value, Opt = unknown>(storage: unknown): storage is StorageInterface<Key, Value, Opt>;
+
 /**
  * Extract all possible value types from an object type
  *
@@ -9882,4 +9536,4 @@ type PartialDeep<T> = {
     [K in keyof T]?: T[K] extends object ? PartialDeep<T[K]> : T[K];
 };
 
-export { ABORT_ERROR_ID, AbortError, Aborter, type AborterConfig, type AborterConfigExtractor, type AborterId, type AborterInterface, AborterPlugin, type AborterPluginOptions, type AsyncStorageInterface, Base64Serializer, BasePluginExecutor, DEFAULT_HOOK_ON_BEFORE, DEFAULT_HOOK_ON_ERROR, DEFAULT_HOOK_ON_EXEC, DEFAULT_HOOK_ON_FINALLY, DEFAULT_HOOK_ON_SUCCESS, EXECUTOR_ASYNC_ERROR, EXECUTOR_ERROR_NAME, EXECUTOR_SYNC_ERROR, type EncryptorInterface, type ExecutorAsyncTask, ExecutorContextImpl, type ExecutorContextInterface, ExecutorError, type ExecutorErrorType, type ExecutorHookRuntimesInterface, type ExecutorInterface, type ExecutorPluginInterface, type ExecutorPluginNameType, type ExecutorSyncTask, type ExecutorTask, type ExpireOptions, type HeaderInjectorConfig, type HeaderInjectorInterface, type HookRuntimes, type HttpMethodType, HttpMethods, type Intersection, JSONSerializer, type JSONSerializerOptions, KeyStorage, type KeyStorageInterface, type KeyStorageOptions, type LifecycleErrorResult, type LifecycleExecResult, LifecycleExecutor, type LifecyclePluginInterface, LifecycleSyncExecutor, type LifecycleSyncPluginInterface, ObjectStorage, type ObjectStorageOptions, type PartialDeep, type PipeArg, type PluginExecutorConfig, RETRY_ERROR_ID, RequestAdapterAxios, type RequestAdapterConfig, type RequestAdapterContext, RequestAdapterFetch, type RequestAdapterFetchConfig, type RequestAdapterInterface, type RequestAdapterResponse, RequestExecutor, type RequestExecutorInterface, RequestHeaderInjector, RequestPlugin, type RequestPluginConfig, type RequestPluginInnerConfig, type ResponseParser, type ResponseParsers, ResponsePlugin, type ResponsePluginConfig, type ResponsePluginContext, RetryPlugin, type SerializerIneterface, SimpleUrlBuilder, type StorageValue, SyncStorage, type SyncStorageInterface, type UrlBuilderInterface, type ValueOf, appendHeaders, createAbortPromise, hasObjectKey, hasObjectKeyWithValue, isAbortError, isAbsoluteUrl, isAsString, isRequestAdapterResponse, normalizeHookNames, raceWithAbort, runPluginHook, runPluginsHookAsync, runPluginsHookSync, runPluginsHooksAsync, runPluginsHooksSync };
+export { ABORT_ERROR_ID, AbortError, Aborter, type AborterConfig, type AborterConfigExtractor, type AborterId, type AborterInterface, AborterPlugin, type AborterPluginOptions, type AsyncStorageInterface, Base64Serializer, BasePluginExecutor, DEFAULT_HOOK_ON_BEFORE, DEFAULT_HOOK_ON_ERROR, DEFAULT_HOOK_ON_EXEC, DEFAULT_HOOK_ON_FINALLY, DEFAULT_HOOK_ON_SUCCESS, EXECUTOR_ASYNC_ERROR, EXECUTOR_ERROR_NAME, EXECUTOR_SYNC_ERROR, type EncryptorInterface, type ExecutorAsyncTask, ExecutorContextImpl, type ExecutorContextInterface, ExecutorError, type ExecutorErrorType, type ExecutorHookRuntimesInterface, type ExecutorInterface, type ExecutorPluginInterface, type ExecutorPluginNameType, type ExecutorSyncTask, type ExecutorTask, type HeaderInjectorConfig, type HeaderInjectorInterface, type HookRuntimes, type HttpMethodType, HttpMethods, type Intersection, JSONSerializer, type JSONSerializerOptions, KeyStorage, type KeyStorageInterface, type LifecycleErrorResult, type LifecycleExecResult, LifecycleExecutor, type LifecyclePluginInterface, LifecycleSyncExecutor, type LifecycleSyncPluginInterface, ObjectStorage, type ObjectStorageOptions, type PartialDeep, type PluginExecutorConfig, RETRY_ERROR_ID, RequestAdapterAxios, type RequestAdapterConfig, type RequestAdapterContext, RequestAdapterFetch, type RequestAdapterFetchConfig, type RequestAdapterInterface, type RequestAdapterResponse, RequestExecutor, type RequestExecutorInterface, RequestHeaderInjector, RequestPlugin, type RequestPluginConfig, type RequestPluginInnerConfig, type ResponseParser, type ResponseParsers, ResponsePlugin, type ResponsePluginConfig, type ResponsePluginContext, RetryPlugin, type SerializerIneterface, SimpleUrlBuilder, StorageExecutor, type StorageExecutorPlugin, type StorageInterface, type StorageValue, type UrlBuilderInterface, type ValueOf, appendHeaders, createAbortPromise, createStoragePlugin, createStoragePluginWithStorage, hasObjectKey, hasObjectKeyWithValue, isAbortError, isAbsoluteUrl, isAsString, isEncryptor, isRequestAdapterResponse, isSerializer, isStorage, normalizeHookNames, raceWithAbort, runPluginHook, runPluginsHookAsync, runPluginsHookSync, runPluginsHooksAsync, runPluginsHooksSync };