@data-client/core 0.1.0

package/ts3.4/legacyActions.d.ts

@@ -0,0 +1,95 @@
+import { UpdateFunction, Schema, EndpointExtraOptions, EndpointInterface } from '@data-client/normalizr';
+import { FSAWithPayloadAndMeta, FSAWithMeta } from 'flux-standard-action';
+import { RECEIVE_TYPE, RESET_TYPE, FETCH_TYPE, SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE, INVALIDATE_TYPE, GC_TYPE, OPTIMISTIC_TYPE } from './actionTypes.js';
+import { EndpointUpdateFunction } from './controller/types.js';
+import { FetchShape } from './endpoint/index.js';
+import { ErrorableFSAWithPayloadAndMeta } from './fsa.js';
+export interface ReceiveMeta<S extends Schema | undefined> {
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    fetchedAt?: number;
+    date: number;
+    expiresAt: number;
+    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+}
+export type ReceiveAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> = ErrorableFSAWithPayloadAndMeta<typeof RECEIVE_TYPE, Payload, ReceiveMeta<S>>;
+export type OptimisticAction<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+} = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+}> = {
+    type: typeof OPTIMISTIC_TYPE;
+    meta: {
+        schema: E['schema'];
+        key: string;
+        args: readonly any[];
+        update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+        fetchedAt: number;
+        date: number;
+        expiresAt: number;
+        errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+    };
+    endpoint: E;
+    error?: undefined;
+};
+export interface ResetAction {
+    type: typeof RESET_TYPE;
+    date: number | Date;
+}
+interface FetchMeta<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> {
+    type: FetchShape<any, any>['type'];
+    schema?: S;
+    key: string;
+    args?: readonly any[];
+    updaters?: Record<string, UpdateFunction<S, any>>;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    options?: EndpointExtraOptions;
+    throttle: boolean;
+    resolve: (value?: any | PromiseLike<any>) => void;
+    reject: (reason?: any) => void;
+    promise: PromiseLike<any>;
+    createdAt: number | Date;
+    optimisticResponse?: Payload;
+    nm?: boolean;
+}
+export interface FetchAction<Payload extends object | string | number | null = object | string | number | null, S extends Schema | undefined = any> extends FSAWithPayloadAndMeta<typeof FETCH_TYPE, () => Promise<Payload>, FetchMeta<any, any>> {
+    meta: FetchMeta<Payload, S>;
+    endpoint?: undefined;
+}
+export interface SubscribeAction extends FSAWithMeta<typeof SUBSCRIBE_TYPE, undefined, any> {
+    meta: {
+        args?: readonly any[];
+        schema: Schema | undefined;
+        fetch: () => Promise<any>;
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+    endpoint?: undefined;
+}
+export interface UnsubscribeAction extends FSAWithMeta<typeof UNSUBSCRIBE_TYPE, undefined, any> {
+    meta: {
+        args?: readonly any[];
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+    endpoint?: undefined;
+}
+export interface InvalidateAction extends FSAWithMeta<typeof INVALIDATE_TYPE, undefined, any> {
+    meta: {
+        key: string;
+    };
+}
+export interface GCAction {
+    type: typeof GC_TYPE;
+    entities: [
+        string,
+        string
+    ][];
+    results: string[];
+}
+export type ActionTypes = FetchAction | OptimisticAction | ReceiveAction | SubscribeAction | UnsubscribeAction | InvalidateAction | ResetAction | GCAction;
+export {};
+//# sourceMappingURL=legacyActions.d.ts.map

package/ts3.4/manager/ConnectionListener.d.ts

@@ -0,0 +1,8 @@
+export default interface ConnectionListener {
+    isOnline: () => boolean;
+    addOnlineListener: (handler: () => void) => void;
+    removeOnlineListener: (handler: () => void) => void;
+    addOfflineListener: (handler: () => void) => void;
+    removeOfflineListener: (handler: () => void) => void;
+}
+//# sourceMappingURL=ConnectionListener.d.ts.map

package/ts3.4/manager/DefaultConnectionListener.d.ts

@@ -0,0 +1,20 @@
+import ConnectionListener from './ConnectionListener.js';
+export declare class BrowserConnectionListener implements ConnectionListener {
+    isOnline(): boolean;
+    addOnlineListener(handler: () => void): void;
+    removeOnlineListener(handler: () => void): void;
+    addOfflineListener(handler: () => void): void;
+    removeOfflineListener(handler: () => void): void;
+}
+export declare class AlwaysOnlineConnectionListener implements ConnectionListener {
+    isOnline(): boolean;
+    addOnlineListener(): void;
+    removeOnlineListener(): void;
+    addOfflineListener(): void;
+    removeOfflineListener(): void;
+}
+declare let DefaultConnectionListener: {
+    new (): ConnectionListener;
+};
+export default DefaultConnectionListener;
+//# sourceMappingURL=DefaultConnectionListener.d.ts.map

package/ts3.4/manager/DevtoolsManager.d.ts

@@ -0,0 +1,24 @@
+import { DevToolsConfig } from './devtoolsTypes.js';
+import { Middleware } from './LogoutManager.js';
+import { Manager, State, ActionTypes } from '../types.js';
+export { DevToolsConfig };
+/** Integrates with https://github.com/reduxjs/redux-devtools
+ *
+ * Options: https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md
+ *
+ * @see https://resthooks.io/docs/api/DevToolsManager
+ */
+export default class DevToolsManager implements Manager {
+    protected middleware: Middleware;
+    protected devTools: undefined | any;
+    constructor(config?: DevToolsConfig, skipLogging?: (action: ActionTypes) => boolean);
+    /** Called when initial state is ready */
+    init(state: State<any>): void;
+    /** Ensures all subscriptions are cleaned up. */
+    cleanup(): void;
+    /** Attaches Manager to store
+     *
+     */
+    getMiddleware(): Middleware;
+}
+//# sourceMappingURL=DevtoolsManager.d.ts.map

package/ts3.4/manager/LogoutManager.d.ts

@@ -0,0 +1,25 @@
+import Controller from '../controller/Controller.js';
+import { UnknownError } from '../index.js';
+import { CombinedActionTypes } from '../types.js';
+import { Manager } from '../types.js';
+/** Handling network unauthorized indicators like HTTP 401
+ *
+ * @see https://resthooks.io/docs/api/LogoutManager
+ */
+export default class LogoutManager implements Manager<CombinedActionTypes> {
+    protected middleware: Middleware;
+    constructor({ handleLogout, shouldLogout }?: Props);
+    cleanup(): void;
+    getMiddleware(): Middleware;
+    protected shouldLogout(error: UnknownError): boolean;
+    handleLogout(controller: Controller<Dispatch>): void;
+}
+type Dispatch = (value: CombinedActionTypes) => Promise<void>;
+export type Middleware = <C extends Controller<Dispatch>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
+type HandleLogout = (controller: Controller<Dispatch>) => void;
+interface Props {
+    handleLogout?: HandleLogout;
+    shouldLogout?: (error: UnknownError) => boolean;
+}
+export {};
+//# sourceMappingURL=LogoutManager.d.ts.map

package/ts3.4/manager/NetworkManager.d.ts

@@ -0,0 +1,82 @@
+import Controller from '../controller/Controller.js';
+import { FetchAction, ReceiveAction, Manager, ActionTypes, Middleware, State } from '../types.js';
+export declare class ResetError extends Error {
+    name: string;
+    constructor();
+}
+/** Handles all async network dispatches
+ *
+ * Dedupes concurrent requests by keeping track of all fetches in flight
+ * and returning existing promises for requests already in flight.
+ *
+ * Interfaces with store via a redux-compatible middleware.
+ *
+ * @see https://resthooks.io/docs/api/NetworkManager
+ */
+export default class NetworkManager implements Manager {
+    protected fetched: {
+        [k: string]: Promise<any>;
+    };
+    protected resolvers: {
+        [k: string]: (value?: any) => void;
+    };
+    protected rejectors: {
+        [k: string]: (value?: any) => void;
+    };
+    protected fetchedAt: {
+        [k: string]: number;
+    };
+    readonly dataExpiryLength: number;
+    readonly errorExpiryLength: number;
+    protected middleware: Middleware;
+    protected getState: () => State<unknown>;
+    protected controller: Controller;
+    cleanupDate?: number;
+    constructor(dataExpiryLength?: number, errorExpiryLength?: number);
+    /** Used by DevtoolsManager to determine whether to log an action */
+    skipLogging(action: ActionTypes): boolean;
+    /** On mount */
+    init(): void;
+    /** Ensures all promises are completed by rejecting remaining. */
+    cleanup(): void;
+    allSettled(): Promise<PromiseSettledResult<any>[]> | undefined;
+    /** Clear all promise state */
+    protected clearAll(): void;
+    /** Clear promise state for a given key */
+    protected clear(key: string): void;
+    protected getLastReset(): number;
+    /** Called when middleware intercepts 'rest-hooks/fetch' action.
+     *
+     * Will then start a promise for a key and potentially start the network
+     * fetch.
+     *
+     * Uses throttle only when instructed by action meta. This is valuable
+     * for ensures mutation requests always go through.
+     */
+    protected handleFetch(action: FetchAction, dispatch: (action: any) => Promise<void>, controller: Controller): Promise<any>;
+    /** Called when middleware intercepts a receive action.
+     *
+     * Will resolve the promise associated with receive key.
+     */
+    protected handleReceive(action: ReceiveAction): void;
+    /** Attaches NetworkManager to store
+     *
+     * Intercepts 'rest-hooks/fetch' actions to start requests.
+     *
+     * Resolve/rejects a request when matching 'rest-hooks/receive' event
+     * is seen.
+     */
+    getMiddleware(): Middleware;
+    /** Ensures only one request for a given key is in flight at any time
+     *
+     * Uses key to either retrieve in-flight promise, or if not
+     * create a new promise and call fetch.
+     *
+     * Note: The new promise is not actually tied to fetch at all,
+     * but is resolved when the expected 'recieve' action is processed.
+     * This ensures promises are resolved only once their data is processed
+     * by the reducer.
+     */
+    protected throttle(key: string, fetch: () => Promise<any>, createdAt: number): Promise<any>;
+}
+//# sourceMappingURL=NetworkManager.d.ts.map

package/ts3.4/manager/PollingSubscription.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from '@data-client/normalizr';
+import ConnectionListener from './ConnectionListener.js';
+import { Subscription, SubscriptionInit } from './SubscriptionManager.js';
+import { State, Dispatch } from '../types.js';
+/**
+ * PollingSubscription keeps a given resource updated by
+ * dispatching a fetch at a rate equal to the minimum update
+ * interval requested.
+ *
+ * @see https://resthooks.io/docs/api/PollingSubscription
+ */
+export default class PollingSubscription implements Subscription {
+    protected readonly schema: Schema | undefined;
+    protected readonly fetch: () => Promise<any>;
+    protected readonly key: string;
+    protected frequency: number;
+    protected frequencyHistogram: Map<number, number>;
+    protected dispatch: Dispatch<any>;
+    protected getState: () => State<unknown>;
+    protected intervalId?: ReturnType<typeof setInterval>;
+    protected lastIntervalId?: ReturnType<typeof setInterval>;
+    protected startId?: ReturnType<typeof setTimeout>;
+    private connectionListener;
+    constructor({ key, schema, fetch, frequency, getState }: SubscriptionInit, dispatch: Dispatch<any>, connectionListener?: ConnectionListener);
+    /** Subscribe to a frequency */
+    add(frequency?: number): void;
+    /** Unsubscribe from a frequency */
+    remove(frequency?: number): boolean;
+    /** Cleanup means clearing out background interval. */
+    cleanup(): void;
+    /** Trigger request for latest resource */
+    protected update(): void;
+    /** What happens when browser goes offline */
+    protected offlineListener: () => void;
+    /** What happens when browser comes online */
+    protected onlineListener: () => void;
+    /** Run polling process with current frequency
+     *
+     * Will clean up old poll interval on next run
+     */
+    protected run(): void;
+    /** Last fetch time */
+    protected lastFetchTime(): number;
+}
+//# sourceMappingURL=PollingSubscription.d.ts.map

package/ts3.4/manager/SubscriptionManager.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from '@data-client/normalizr';
+import { Manager, State, Middleware, Dispatch, UnsubscribeAction, SubscribeAction } from '../types.js';
+/** Properties sent to Subscription constructor */
+export interface SubscriptionInit {
+    schema?: Schema | undefined;
+    fetch: () => Promise<any>;
+    key: string;
+    getState: () => State<unknown>;
+    frequency?: number | undefined;
+}
+/** Interface handling a single resource subscription */
+export interface Subscription {
+    add(frequency?: number): void;
+    remove(frequency?: number): boolean;
+    cleanup(): void;
+}
+/** The static class that constructs Subscription */
+export interface SubscriptionConstructable {
+    new (init: SubscriptionInit, dispatch: Dispatch<any>): Subscription;
+}
+/** Handles subscription actions -> fetch or receive actions
+ *
+ * Constructor takes a SubscriptionConstructable class to control how
+ * subscriptions are handled. (e.g., polling, websockets)
+ *
+ * @see https://resthooks.io/docs/api/SubscriptionManager
+ */
+export default class SubscriptionManager<S extends SubscriptionConstructable> implements Manager {
+    protected subscriptions: {
+        [key: string]: InstanceType<S>;
+    };
+    protected readonly Subscription: S;
+    protected middleware: Middleware;
+    constructor(Subscription: S);
+    /** Ensures all subscriptions are cleaned up. */
+    cleanup(): void;
+    /** Called when middleware intercepts 'rest-hooks/subscribe' action.
+     *
+     */
+    protected handleSubscribe(action: SubscribeAction, dispatch: (action: any) => Promise<void>, getState: () => State<unknown>): void;
+    /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
+     *
+     */
+    protected handleUnsubscribe(action: UnsubscribeAction, dispatch: (action: any) => Promise<void>): void;
+    /** Attaches Manager to store
+     *
+     * Intercepts 'rest-hooks/subscribe'/'rest-hooks/unsubscribe' to register resources that
+     * need to be kept up to date.
+     *
+     * Will possibly dispatch 'rest-hooks/fetch' or 'rest-hooks/receive' to keep resources fresh
+     *
+     */
+    getMiddleware(): Middleware;
+}
+//# sourceMappingURL=SubscriptionManager.d.ts.map

package/ts3.4/manager/applyManager.d.ts

@@ -0,0 +1,10 @@
+import Controller from '../controller/Controller.js';
+import { Reducer, Dispatch, ReducerState } from '../middlewareTypes.js';
+import { Manager } from '../types.js';
+export default function applyManager(managers: Manager[], controller: Controller): Middleware[];
+export interface MiddlewareAPI<R extends Reducer<any, any> = Reducer<any, any>> {
+    getState: () => ReducerState<R>;
+    dispatch: Dispatch<R>;
+}
+export type Middleware = <R extends Reducer<any, any>>({ dispatch, }: MiddlewareAPI<R>) => (next: Dispatch<R>) => Dispatch<R>;
+//# sourceMappingURL=applyManager.d.ts.map

package/ts3.4/manager/devtoolsTypes.d.ts

@@ -0,0 +1,205 @@
+type Action = any;
+type ActionCreator<T> = any;
+export interface EnhancerOptions {
+    /**
+     * the instance name to be showed on the monitor page. Default value is `document.title`.
+     * If not specified and there's no document title, it will consist of `tabId` and `instanceId`.
+     */
+    name?: string;
+    /**
+     * action creators functions to be available in the Dispatcher.
+     */
+    actionCreators?: ActionCreator<any>[] | {
+        [key: string]: ActionCreator<any>;
+    };
+    /**
+     * if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once.
+     * It is the joint between performance and speed. When set to `0`, all actions will be sent instantly.
+     * Set it to a higher value when experiencing perf issues (also `maxAge` to a lower value).
+     *
+     * @default 500 ms.
+     */
+    latency?: number;
+    /**
+     * (> 1) - maximum allowed actions to be stored in the history tree. The oldest actions are removed once maxAge is reached. It's critical for performance.
+     *
+     * @default 50
+     */
+    maxAge?: number;
+    /**
+     * Customizes how actions and state are serialized and deserialized. Can be a boolean or object. If given a boolean, the behavior is the same as if you
+     * were to pass an object and specify `options` as a boolean. Giving an object allows fine-grained customization using the `replacer` and `reviver`
+     * functions.
+     */
+    serialize?: boolean | {
+        /**
+         * - `undefined` - will use regular `JSON.stringify` to send data (it's the fast mode).
+         * - `false` - will handle also circular references.
+         * - `true` - will handle also date, regex, undefined, error objects, symbols, maps, sets and functions.
+         * - object, which contains `date`, `regex`, `undefined`, `error`, `symbol`, `map`, `set` and `function` keys.
+         *   For each of them you can indicate if to include (by setting as `true`).
+         *   For `function` key you can also specify a custom function which handles serialization.
+         *   See [`jsan`](https://github.com/kolodny/jsan) for more details.
+         */
+        options?: undefined | boolean | {
+            date?: true;
+            regex?: true;
+            undefined?: true;
+            error?: true;
+            symbol?: true;
+            map?: true;
+            set?: true;
+            function?: true | ((fn: (...args: any[]) => any) => string);
+        };
+        /**
+         * [JSON replacer function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter) used for both actions and states stringify.
+         * In addition, you can specify a data type by adding a [`__serializedType__`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/helpers/index.js#L4)
+         * key. So you can deserialize it back while importing or persisting data.
+         * Moreover, it will also [show a nice preview showing the provided custom type](https://cloud.githubusercontent.com/assets/7957859/21814330/a17d556a-d761-11e6-85ef-159dd12f36c5.png):
+         */
+        replacer?: (key: string, value: unknown) => any;
+        /**
+         * [JSON `reviver` function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Using_the_reviver_parameter)
+         * used for parsing the imported actions and states. See [`remotedev-serialize`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/immutable/serialize.js#L8-L41)
+         * as an example on how to serialize special data types and get them back.
+         */
+        reviver?: (key: string, value: unknown) => any;
+    };
+    /**
+     * function which takes `action` object and id number as arguments, and should return `action` object back.
+     */
+    actionSanitizer?: <A extends Action>(action: A, id: number) => A;
+    /**
+     * function which takes `state` object and index as arguments, and should return `state` object back.
+     */
+    stateSanitizer?: <S>(state: S, index: number) => S;
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsWhitelist` specified, `actionsBlacklist` is ignored.
+     * @deprecated Use actionsDenylist instead.
+     */
+    actionsBlacklist?: string | string[];
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsWhitelist` specified, `actionsBlacklist` is ignored.
+     * @deprecated Use actionsAllowlist instead.
+     */
+    actionsWhitelist?: string | string[];
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+     */
+    actionsDenylist?: string | string[];
+    /**
+     * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+     * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+     */
+    actionsAllowlist?: string | string[];
+    /**
+     * called for every action before sending, takes `state` and `action` object, and returns `true` in case it allows sending the current data to the monitor.
+     * Use it as a more advanced version of `actionsDenylist`/`actionsAllowlist` parameters.
+     */
+    predicate?: <S, A extends Action>(state: S, action: A) => boolean;
+    /**
+     * if specified as `false`, it will not record the changes till clicking on `Start recording` button.
+     * Available only for Redux enhancer, for others use `autoPause`.
+     *
+     * @default true
+     */
+    shouldRecordChanges?: boolean;
+    /**
+     * if specified, whenever clicking on `Pause recording` button and there are actions in the history log, will add this action type.
+     * If not specified, will commit when paused. Available only for Redux enhancer.
+     *
+     * @default "@@PAUSED""
+     */
+    pauseActionType?: string;
+    /**
+     * auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use.
+     * Not available for Redux enhancer (as it already does it but storing the data to be sent).
+     *
+     * @default false
+     */
+    autoPause?: boolean;
+    /**
+     * if specified as `true`, it will not allow any non-monitor actions to be dispatched till clicking on `Unlock changes` button.
+     * Available only for Redux enhancer.
+     *
+     * @default false
+     */
+    shouldStartLocked?: boolean;
+    /**
+     * if set to `false`, will not recompute the states on hot reloading (or on replacing the reducers). Available only for Redux enhancer.
+     *
+     * @default true
+     */
+    shouldHotReload?: boolean;
+    /**
+     * if specified as `true`, whenever there's an exception in reducers, the monitors will show the error message, and next actions will not be dispatched.
+     *
+     * @default false
+     */
+    shouldCatchErrors?: boolean;
+    /**
+     * If you want to restrict the extension, specify the features you allow.
+     * If not specified, all of the features are enabled. When set as an object, only those included as `true` will be allowed.
+     * Note that except `true`/`false`, `import` and `export` can be set as `custom` (which is by default for Redux enhancer), meaning that the importing/exporting occurs on the client side.
+     * Otherwise, you'll get/set the data right from the monitor part.
+     */
+    features?: {
+        /**
+         * start/pause recording of dispatched actions
+         */
+        pause?: boolean;
+        /**
+         * lock/unlock dispatching actions and side effects
+         */
+        lock?: boolean;
+        /**
+         * persist states on page reloading
+         */
+        persist?: boolean;
+        /**
+         * export history of actions in a file
+         */
+        export?: boolean | 'custom';
+        /**
+         * import history of actions from a file
+         */
+        import?: boolean | 'custom';
+        /**
+         * jump back and forth (time travelling)
+         */
+        jump?: boolean;
+        /**
+         * skip (cancel) actions
+         */
+        skip?: boolean;
+        /**
+         * drag and drop actions in the history list
+         */
+        reorder?: boolean;
+        /**
+         * dispatch custom actions or action creators
+         */
+        dispatch?: boolean;
+        /**
+         * generate tests for the selected actions
+         */
+        test?: boolean;
+    };
+    /**
+     * Set to true or a stacktrace-returning function to record call stack traces for dispatched actions.
+     * Defaults to false.
+     */
+    trace?: boolean | (<A extends Action>(action: A) => string);
+    /**
+     * The maximum number of stack trace entries to record per action. Defaults to 10.
+     */
+    traceLimit?: number;
+}
+export interface DevToolsConfig extends EnhancerOptions {
+    type?: string;
+}
+export {};
+//# sourceMappingURL=devtoolsTypes.d.ts.map

package/ts3.4/manager/index.d.ts

@@ -0,0 +1,8 @@
+export { default as ConnectionListener } from './ConnectionListener.js';
+export { default as DefaultConnectionListener } from './DefaultConnectionListener.js';
+export { default as PollingSubscription } from './PollingSubscription.js';
+export { default as SubscriptionManager } from './SubscriptionManager.js';
+export { default as DevToolsManager } from './DevtoolsManager.js';
+export { default as LogoutManager } from './LogoutManager.js';
+export { DevToolsConfig } from './DevtoolsManager.js';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/middlewareTypes.d.ts

@@ -0,0 +1,18 @@
+import Controller from './controller/Controller.js';
+import { ActionTypes } from './newActions.js';
+import { ActionTypes as LegacyActionTypes, CombinedActionTypes, State } from './types.js';
+type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
+export interface MiddlewareAPI<R extends RestHooksReducer = RestHooksReducer> extends Controller<RHDispatch<CombinedActionTypes>> {
+    controller: Controller<RHDispatch<CombinedActionTypes>>;
+}
+export interface MiddlewareController<Actions = LegacyActionTypes> extends Controller<RHDispatch<Actions>> {
+    controller: Controller<RHDispatch<Actions>>;
+}
+export type Middleware<Actions = any> = <C extends MiddlewareController<Actions>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
+export type RestHooksReducer = (prevState: State<unknown>, action: ActionTypes) => State<unknown>;
+export type Dispatch<R extends Reducer<any, any>> = (action: ReducerAction<R>) => Promise<void>;
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any> ? S : never;
+export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<any, infer A> ? A : never;
+export {};
+//# sourceMappingURL=middlewareTypes.d.ts.map