@dxyl/utils 1.1.7 → 1.2.0

package/types/data/redux/types/store.d.ts

@@ -0,0 +1,190 @@
+import { Action, UnknownAction } from './actions';
+import { Reducer } from './reducers';
+/**
+ * A *dispatching function* (or simply *dispatch function*) is a function that
+ * accepts an action or an async action; it then may or may not dispatch one
+ * or more actions to the store.
+ *
+ * We must distinguish between dispatching functions in general and the base
+ * `dispatch` function provided by the store instance without any middleware.
+ *
+ * The base dispatch function *always* synchronously sends an action to the
+ * store's reducer, along with the previous state returned by the store, to
+ * calculate a new state. It expects actions to be plain objects ready to be
+ * consumed by the reducer.
+ *
+ * Middleware wraps the base dispatch function. It allows the dispatch
+ * function to handle async actions in addition to actions. Middleware may
+ * transform, delay, ignore, or otherwise interpret actions or async actions
+ * before passing them to the next middleware.
+ *
+ * @template A The type of things (actions or otherwise) which may be
+ *   dispatched.
+ */
+export interface Dispatch<A extends Action = UnknownAction> {
+    <T extends A>(action: T, ...extraArgs: any[]): T;
+}
+/**
+ * Function to remove listener added by `Store.subscribe()`.
+ */
+export interface Unsubscribe {
+    (): void;
+}
+export type ListenerCallback = () => void;
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+/**
+ * A minimal observable of state changes.
+ * For more information, see the observable proposal:
+ * https://github.com/tc39/proposal-observable
+ */
+export type Observable<T> = {
+    /**
+     * The minimal observable subscription method.
+     * @param {Object} observer Any object that can be used as an observer.
+     * The observer object should have a `next` method.
+     * @returns {subscription} An object with an `unsubscribe` method that can
+     * be used to unsubscribe the observable from the store, and prevent further
+     * emission of values from the observable.
+     */
+    subscribe: (observer: Observer<T>) => {
+        unsubscribe: Unsubscribe;
+    };
+    [Symbol.observable](): Observable<T>;
+};
+/**
+ * An Observer is used to receive data from an Observable, and is supplied as
+ * an argument to subscribe.
+ */
+export type Observer<T> = {
+    next?(value: T): void;
+};
+/**
+ * A store is an object that holds the application's state tree.
+ * There should only be a single store in a Redux app, as the composition
+ * happens on the reducer level.
+ *
+ * @template S The type of state held by this store.
+ * @template A the type of actions which may be dispatched by this store.
+ * @template StateExt any extension to state from store enhancers
+ */
+export interface Store<S = any, A extends Action = UnknownAction, StateExt extends unknown = unknown> {
+    /**
+     * Dispatches an action. It is the only way to trigger a state change.
+     *
+     * The `reducer` function, used to create the store, will be called with the
+     * current state tree and the given `action`. Its return value will be
+     * considered the **next** state of the tree, and the change listeners will
+     * be notified.
+     *
+     * The base implementation only supports plain object actions. If you want
+     * to dispatch a Promise, an Observable, a thunk, or something else, you
+     * need to wrap your store creating function into the corresponding
+     * middleware. For example, see the documentation for the `redux-thunk`
+     * package. Even the middleware will eventually dispatch plain object
+     * actions using this method.
+     *
+     * @param action A plain object representing “what changed”. It is a good
+     *   idea to keep actions serializable so you can record and replay user
+     *   sessions, or use the time travelling `redux-devtools`. An action must
+     *   have a `type` property which may not be `undefined`. It is a good idea
+     *   to use string constants for action types.
+     *
+     * @returns For convenience, the same action object you dispatched.
+     *
+     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+     * return something else (for example, a Promise you can await).
+     */
+    dispatch: Dispatch<A>;
+    /**
+     * Reads the state tree managed by the store.
+     *
+     * @returns The current state tree of your application.
+     */
+    getState(): S & StateExt;
+    /**
+     * Adds a change listener. It will be called any time an action is
+     * dispatched, and some part of the state tree may potentially have changed.
+     * You may then call `getState()` to read the current state tree inside the
+     * callback.
+     *
+     * You may call `dispatch()` from a change listener, with the following
+     * caveats:
+     *
+     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+     * If you subscribe or unsubscribe while the listeners are being invoked,
+     * this will not have any effect on the `dispatch()` that is currently in
+     * progress. However, the next `dispatch()` call, whether nested or not,
+     * will use a more recent snapshot of the subscription list.
+     *
+     * 2. The listener should not expect to see all states changes, as the state
+     * might have been updated multiple times during a nested `dispatch()` before
+     * the listener is called. It is, however, guaranteed that all subscribers
+     * registered before the `dispatch()` started will be called with the latest
+     * state by the time it exits.
+     *
+     * @param listener A callback to be invoked on every dispatch.
+     * @returns A function to remove this change listener.
+     */
+    subscribe(listener: ListenerCallback): Unsubscribe;
+    /**
+     * Replaces the reducer currently used by the store to calculate the state.
+     *
+     * You might need this if your app implements code splitting and you want to
+     * load some of the reducers dynamically. You might also need this if you
+     * implement a hot reloading mechanism for Redux.
+     *
+     * @param nextReducer The reducer for the store to use instead.
+     */
+    replaceReducer(nextReducer: Reducer<S, A>): void;
+    /**
+     * Interoperability point for observable/reactive libraries.
+     * @returns {observable} A minimal observable of state changes.
+     * For more information, see the observable proposal:
+     * https://github.com/tc39/proposal-observable
+     */
+    [Symbol.observable](): Observable<S & StateExt>;
+}
+export type UnknownIfNonSpecific<T> = {} extends T ? unknown : T;
+/**
+ * A store creator is a function that creates a Redux store. Like with
+ * dispatching function, we must distinguish the base store creator,
+ * `createStore(reducer, preloadedState)` exported from the Redux package, from
+ * store creators that are returned from the store enhancers.
+ *
+ * @template S The type of state to be held by the store.
+ * @template A The type of actions which may be dispatched.
+ * @template PreloadedState The initial state that is passed into the reducer.
+ * @template Ext Store extension that is mixed in to the Store type.
+ * @template StateExt State extension that is mixed into the state type.
+ */
+export interface StoreCreator {
+    <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}>(reducer: Reducer<S, A>, enhancer?: StoreEnhancer<Ext, StateExt>): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext;
+    <S, A extends Action, Ext extends {} = {}, StateExt extends {} = {}, PreloadedState = S>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined, enhancer?: StoreEnhancer<Ext>): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext;
+}
+/**
+ * A store enhancer is a higher-order function that composes a store creator
+ * to return a new, enhanced store creator. This is similar to middleware in
+ * that it allows you to alter the store interface in a composable way.
+ *
+ * Store enhancers are much the same concept as higher-order components in
+ * React, which are also occasionally called “component enhancers”.
+ *
+ * Because a store is not an instance, but rather a plain-object collection of
+ * functions, copies can be easily created and modified without mutating the
+ * original store. There is an example in `compose` documentation
+ * demonstrating that.
+ *
+ * Most likely you'll never write a store enhancer, but you may use the one
+ * provided by the developer tools. It is what makes time travel possible
+ * without the app being aware it is happening. Amusingly, the Redux
+ * middleware implementation is itself a store enhancer.
+ *
+ * @template Ext Store extension that is mixed into the Store type.
+ * @template StateExt State extension that is mixed into the state type.
+ */
+export type StoreEnhancer<Ext extends {} = {}, StateExt extends {} = {}> = <NextExt extends {}, NextStateExt extends {}>(next: StoreEnhancerStoreCreator<NextExt, NextStateExt>) => StoreEnhancerStoreCreator<NextExt & Ext, NextStateExt & StateExt>;
+export type StoreEnhancerStoreCreator<Ext extends {} = {}, StateExt extends {} = {}> = <S, A extends Action, PreloadedState>(reducer: Reducer<S, A, PreloadedState>, preloadedState?: PreloadedState | undefined) => Store<S, A, StateExt> & Ext;

package/types/data/redux/utils/actionTypes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * These are private action types reserved by Redux.
+ * For any unknown actions, you must return the current state.
+ * If the current state is undefined, you must return the initial state.
+ * Do not reference these action types directly in your code.
+ */
+declare const ActionTypes: {
+    INIT: string;
+    REPLACE: string;
+    PROBE_UNKNOWN_ACTION: () => string;
+};
+export default ActionTypes;

package/types/data/redux/utils/formatProdErrorMessage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
+ *
+ * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
+ * during build.
+ * @param {number} code
+ */
+export declare function formatProdErrorMessage(code: number): string;

package/types/data/redux/utils/isAction.d.ts

@@ -0,0 +1,2 @@
+import { Action } from '../types/actions';
+export default function isAction(action: unknown): action is Action<string>;

package/types/data/redux/utils/isPlainObject.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param obj The object to inspect.
+ * @returns True if the argument appears to be a plain object.
+ */
+export default function isPlainObject(obj: any): obj is object;

package/types/data/redux/utils/kindOf.d.ts

@@ -0,0 +1,2 @@
+export declare function miniKindOf(val: any): string;
+export declare function kindOf(val: any): string;

package/types/data/redux/utils/symbol-observable.d.ts

@@ -0,0 +1,7 @@
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+declare const $$observable: string | typeof Symbol.observable;
+export default $$observable;

package/types/data/redux/utils/warning.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prints a warning in the console if it exists.
+ *
+ * @param message The warning message.
+ */
+export default function warning(message: string): void;

package/types/events/Observable.d.ts

@@ -1,28 +1,161 @@
-export function merge(...sources: any[]): Observable;
-export function combineLatest(...sources: any[]): Observable;
-export function zip(...sources: any[]): Observable;
-export class Observable {
-    [x: number]: () => this;
-    static from(x: any): Observable;
-    static of(...items: any[]): Observable;
-    constructor(subscriber: any);
-    _subscriber: any;
-    subscribe(observer: any, ...args: any[]): Subscription;
-    forEach(fn: any): Promise<any>;
-    map(fn: any): any;
-    filter(fn: any): any;
-    reduce(fn: any, ...args: any[]): any;
-    all(): Promise<any[]>;
-    concat(...sources: any[]): any;
-    flatMap(fn: any): any;
-}
-declare class Subscription {
-    constructor(observer: any, subscriber: any);
-    _cleanup: any;
-    _observer: any;
-    _queue: any;
-    _state: string;
-    get closed(): boolean;
-    unsubscribe(): void;
-}
-export {};
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+
+    namespace ZenObservable {
+        interface SubscriptionObserver<T> {
+            closed: boolean;
+            next(value: T): void;
+            error(errorValue: any): void;
+            complete(): void;
+        }
+
+        interface Subscription {
+            closed: boolean;
+            unsubscribe(): void;
+        }
+
+        interface Observer<T> {
+            start?(subscription: Subscription): any;
+            next?(value: T): void;
+            error?(errorValue: any): void;
+            complete?(): void;
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+        type Subscriber<T> = (observer: SubscriptionObserver<T>) => void | (() => void) | Subscription;
+
+        interface ObservableLike<T> {
+            subscribe?: Subscriber<T> | undefined;
+            [Symbol.observable](): Observable<T> | ObservableLike<T>;
+        }
+    }
+}
+
+declare class Observable<T> {
+    constructor(subscriber: ZenObservable.Subscriber<T>);
+
+    subscribe(observer: ZenObservable.Observer<T>): ZenObservable.Subscription;
+    subscribe(
+        onNext: (value: T) => void,
+        onError?: (error: any) => void,
+        onComplete?: () => void,
+    ): ZenObservable.Subscription;
+
+    [Symbol.observable](): Observable<T>;
+
+    forEach(callback: (value: T) => void): Promise<void>;
+    map<R>(callback: (value: T) => R): Observable<R>;
+    filter<S extends T>(callback: (value: T) => value is S): Observable<S>;
+    filter(callback: (value: T) => boolean): Observable<T>;
+    reduce(callback: (previousValue: T, currentValue: T) => T, initialValue?: T): Observable<T>;
+    reduce<R>(callback: (previousValue: R, currentValue: T) => R, initialValue?: R): Observable<R>;
+    flatMap<R>(callback: (value: T) => ZenObservable.ObservableLike<R>): Observable<R>;
+    concat<R>(...observable: Array<Observable<R>>): Observable<R>;
+
+    static from<R>(observable: Observable<R> | ZenObservable.ObservableLike<R> | ArrayLike<R>): Observable<R>;
+    static of<R>(...items: R[]): Observable<R>;
+}
+
+declare namespace Observable {}
+
+
+export function merge(): Observable<never>;
+export function merge<A>(a: ZenObservable.ObservableLike<A>): Observable<A>;
+export function merge<A, B>(a: ZenObservable.ObservableLike<A>, b: ZenObservable.ObservableLike<B>): Observable<A | B>;
+export function merge<A, B, C>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+): Observable<A | B | C>;
+export function merge<A, B, C, D>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+): Observable<A | B | C | D>;
+export function merge<A, B, C, D, E>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+    e: ZenObservable.ObservableLike<E>,
+): Observable<A | B | C | D | E>;
+export function merge<A, B, C, D, E, F>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+    e: ZenObservable.ObservableLike<E>,
+    f: ZenObservable.ObservableLike<F>,
+): Observable<A | B | C | D | E | F>;
+export function merge<T>(...observables: Array<ZenObservable.ObservableLike<T>>): Observable<T>;
+
+export function combineLatest(): Observable<never>;
+export function combineLatest<A>(a: ZenObservable.ObservableLike<A>): Observable<[A]>;
+export function combineLatest<A, B>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+): Observable<[A, B]>;
+export function combineLatest<A, B, C>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+): Observable<[A, B, C]>;
+export function combineLatest<A, B, C, D>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+): Observable<[A, B, C, D]>;
+export function combineLatest<A, B, C, D, E>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+    e: ZenObservable.ObservableLike<E>,
+): Observable<[A, B, C, D, E]>;
+export function combineLatest<A, B, C, D, E, F>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+    e: ZenObservable.ObservableLike<E>,
+    f: ZenObservable.ObservableLike<F>,
+): Observable<[A, B, C, D, E, F]>;
+export function combineLatest<T>(...observables: Array<ZenObservable.ObservableLike<T>>): Observable<T[]>;
+
+export function zip(): Observable<never>;
+export function zip<A>(a: ZenObservable.ObservableLike<A>): Observable<[A]>;
+export function zip<A, B>(a: ZenObservable.ObservableLike<A>, b: ZenObservable.ObservableLike<B>): Observable<[A, B]>;
+export function zip<A, B, C>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+): Observable<[A, B, C]>;
+export function zip<A, B, C, D>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+): Observable<[A, B, C, D]>;
+export function zip<A, B, C, D, E>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+    e: ZenObservable.ObservableLike<E>,
+): Observable<[A, B, C, D, E]>;
+export function zip<A, B, C, D, E, F>(
+    a: ZenObservable.ObservableLike<A>,
+    b: ZenObservable.ObservableLike<B>,
+    c: ZenObservable.ObservableLike<C>,
+    d: ZenObservable.ObservableLike<D>,
+    e: ZenObservable.ObservableLike<E>,
+    f: ZenObservable.ObservableLike<F>,
+): Observable<[A, B, C, D, E, F]>;
+export function zip<T>(...observables: Array<ZenObservable.ObservableLike<T>>): Observable<T[]>;
+export  {
+    Observable
+};

package/types/events/Signals.d.ts

@@ -0,0 +1,18 @@
+type HandleContext = {
+    stop: () => void;
+    remove: () => void;
+};
+type Handle<T extends any[]> = (...args: [...T, context: HandleContext]) => void;
+type Options = {
+    stage?: number;
+    once?: boolean;
+};
+type Unsubscribe = () => void;
+interface Signals<T extends any[]> {
+    add(handle: Handle<T>, options?: Options): Unsubscribe;
+    remove(handle: Handle<T>): void;
+    dispatch(...args: T): void;
+    clear(): void;
+}
+export declare function Signals<T extends any[]>(): Signals<T>;
+export {};

package/types/events/eventTarget.d.ts

@@ -45,7 +45,7 @@ export interface EventTarget<Events extends Record<string, any> = {}> {
     emit<K extends Extract<keyof Events, string>>(e: Event<Events[K], K>): void;
 }
 export declare class EventTarget<Events extends Record<string, any> = {}> {
-    parentNode: EventTarget | null;
+    parent: EventTarget | null;
     private _bubble_emitter;
     private _capture_emitter;
     addEventListener<K extends keyof Events>(type: K, fn: EventCallback<Events[K]>, options?: EventOptions | boolean): void;

package/types/index.d.ts

@@ -3,6 +3,8 @@ export * from './events/eventemitter3';
 export * from './events/mitt';
 export { EventEmitter4, Emitter4Event } from './events/eventmitter';
 export { default as mitt } from './events/mitt';
+export * as observable from './events/Observable';
+export { Signals } from './events/Signals';
 export * from './callbacks';
 export * from './ismobilejs';
 export * from './priority_queue';
@@ -15,8 +17,13 @@ export * as immer from './data/immer';
 export * as Immutable from './data/immutable';
 export * as reactivity from './data/reactivity';
 export * as signals from './data/signals';
+export * as redux from './data/redux';
+export * as mobx from './data/mobx';
+export * as tapable from './tapable';
 export { Options } from './Options';
+export { default as compose } from './compose';
 export type { OptionsProperties, OptionConfig } from './Options';
 export { default as deepmerge } from './deepmerge';
 export { default as fastDeepEqual } from './fast-deep-equal';
 export * from './Color';
+export * as colord from './color/colord/src';

package/types/tapable/index.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Checks if `value` is equal to `check` if `check` is a string or in `check` if check is an Array
+ *
+ * @param value - the value being searched for
+ * @param check - the values to check against
+ * @returns `boolean`
+ */
+export declare function equalToOrIn(value: string, check: string | Array<string>): boolean;
+export type Interceptor<Args extends any[], ReturnType, ContextType> = {
+    /** An optional name for the interceptor */
+    name?: string;
+    /** Callback for each loop when used by the hook */
+    loop?: (...args: Args) => void;
+    /** Callback when an error occurs during the hook's call */
+    error?: (err: Error) => void;
+    /** Callback when a result is found for a hook's invocation */
+    result?: (r: ReturnType extends Promise<infer AwaitedValue> ? AwaitedValue : ReturnType) => void;
+    /** Callback when a hook's call is complete */
+    done?: () => void;
+    /** Callback when a hook is tapped */
+    tap?: (tap: Tap<Args, ReturnType, ContextType>) => void;
+} & ({
+    /** If context should be omitted from the 'call'. This is the default */
+    context?: false;
+    /** Callback when the hook is tapped without context */
+    call?: (...args: Args) => void;
+} | {
+    /** If context should be included in the 'call' */
+    context: true;
+    /** Callback when the hook is tapped with context */
+    call?: (context: ContextType, ...args: Args) => void;
+});
+export type Tap<Args extends any[], ReturnType, ContextType = unknown> = {
+    key: symbol;
+    name: string;
+    before?: string | Array<string>;
+} & ({
+    context: false;
+    callback: (...args: Args) => ReturnType;
+} | {
+    context: true;
+    callback: (context: ContextType, ...args: Args) => ReturnType;
+});
+type BasicTap<Args extends any[], ReturnType, ContextType> = (name: string, callback: (...args: Args) => ReturnType, before?: string | Array<string>) => Tap<Args, ReturnType, ContextType>;
+type TapWithContext<Args extends any[], ReturnType, ContextType> = ((options: {
+    name: string;
+    context?: false;
+    before?: string | Array<string>;
+}, callback: (...args: Args) => ReturnType) => Tap<Args, ReturnType>) | ((options: {
+    name: string;
+    context: true;
+    before?: string | Array<string>;
+}, callback: (context: ContextType, ...args: Args) => ReturnType) => Tap<Args, ReturnType>);
+interface SyncBaseHookType<Args extends any[], ReturnType, ContextType> {
+    tap: BasicTap<Args, ReturnType, ContextType> | TapWithContext<Args, ReturnType, ContextType>;
+    call(...args: Args): void;
+    untap(key: Tap<Args, ReturnType>): void;
+    isUsed(): boolean;
+    intercept(int: Interceptor<Args, ReturnType, ContextType>): void;
+}
+/** A manager for all intercepts inside of a tap */
+declare class InterceptionManager<Args extends any[], ReturnType, ContextType = Record<string, any>> {
+    protected interceptions: Array<Interceptor<Args, ReturnType, ContextType>>;
+    private interceptionKeySet;
+    constructor();
+    isUsed(): boolean;
+    intercept(int: Interceptor<Args, ReturnType, ContextType>): void;
+    tap(tap: Tap<Args, ReturnType, ContextType>): void;
+    call(ctx: ContextType, ...args: Args): void;
+    loop(...args: Args): void;
+    error(err: unknown): void;
+    result(r: ReturnType extends Promise<infer AwaitedValue> ? AwaitedValue : ReturnType): void;
+    done(): void;
+}
+declare abstract class Hook<Args extends any[], ReturnType, ContextType = Record<string, any>> implements SyncBaseHookType<Args, ReturnType, ContextType> {
+    protected taps: Array<Tap<Args, ReturnType, ContextType>>;
+    protected interceptions: InterceptionManager<Args, ReturnType, ContextType>;
+    constructor();
+    tap(options: {
+        name: string;
+        context?: false;
+        before?: string | Array<string>;
+    }, callback: (...args: Args) => ReturnType): Tap<Args, ReturnType, ContextType>;
+    tap(options: {
+        name: string;
+        context: true;
+        before?: string | Array<string>;
+    }, callback: (ctx: ContextType, ...args: Args) => ReturnType): Tap<Args, ReturnType, ContextType>;
+    tap(name: string, callback: (...args: Args) => ReturnType): Tap<Args, ReturnType, ContextType>;
+    abstract call(...args: Args): ReturnType;
+    untap(tap: Tap<Args, ReturnType, ContextType>): void;
+    isUsed(): boolean;
+    intercept(int: Interceptor<Args, ReturnType, ContextType>): void;
+}
+export declare class SyncHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, void, ContextType> {
+    call(...args: Args): void;
+}
+export declare class SyncBailHook<Args extends any[], ReturnType, ContextType = Record<string, any>> extends Hook<Args, ReturnType | undefined | null, ContextType> {
+    call(...args: Args): ReturnType | undefined | null;
+}
+export declare class SyncWaterfallHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, Args[0], ContextType> {
+    call(...args: Args): Args[0];
+}
+export declare class SyncLoopHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, void, ContextType> {
+    call(...args: Args): void;
+}
+export declare class AsyncParallelHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, Promise<void>, ContextType> {
+    call(...args: Args): Promise<void>;
+}
+export declare class AsyncParallelBailHook<Args extends any[], ReturnType, ContextType = Record<string, any>> extends Hook<Args, Promise<ReturnType>, ContextType> {
+    call(...args: Args): Promise<ReturnType>;
+}
+export declare class AsyncSeriesHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, Promise<void>, ContextType> {
+    call(...args: Args): Promise<void>;
+}
+export declare class AsyncSeriesBailHook<Args extends any[], ReturnType, ContextType = Record<string, any>> extends Hook<Args, Promise<ReturnType | undefined | null>, ContextType> {
+    call(...args: Args): Promise<ReturnType | undefined | null>;
+}
+export declare class AsyncSeriesWaterfallHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, Promise<Args[0]>, ContextType> {
+    call(...args: Args): Promise<Args[0]>;
+}
+export declare class AsyncSeriesLoopHook<Args extends any[], ContextType = Record<string, any>> extends Hook<Args, Promise<void>, ContextType> {
+    call(...args: Args): Promise<void>;
+}
+export {};