@data-client/core 0.1.0

package/src/types.ts

@@ -0,0 +1,125 @@
+import {
+  EndpointInterface,
+  NormalizedIndex,
+  Schema,
+} from '@data-client/normalizr';
+import type {
+  UpdateFunction,
+  AbstractInstanceType,
+} from '@data-client/normalizr';
+import type { ErrorTypes } from '@data-client/normalizr';
+
+import { RECEIVE_TYPE } from './actionTypes.js';
+import {
+  CompatibleFetchAction,
+  CompatibleReceiveAction,
+  CompatibleSubscribeAction,
+  CompatibleUnsubscribeAction,
+} from './compatibleActions.js';
+import { EndpointUpdateFunction } from './controller/types.js';
+import * as legacyActions from './legacyActions.js';
+import { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
+import * as newActions from './newActions.js';
+import * as previousActions from './previousActions.js';
+
+export type { AbstractInstanceType, UpdateFunction };
+
+export type ReceiveTypes = typeof RECEIVE_TYPE;
+
+export type PK = string;
+
+export interface State<T> {
+  readonly entities: {
+    readonly [entityKey: string]: { readonly [pk: string]: T } | undefined;
+  };
+  readonly indexes: NormalizedIndex;
+  readonly results: { readonly [key: string]: unknown | PK[] | PK | undefined };
+  readonly meta: {
+    readonly [key: string]: {
+      readonly date: number;
+      readonly error?: ErrorTypes;
+      readonly expiresAt: number;
+      readonly prevExpiresAt?: number;
+      readonly invalidated?: boolean;
+      readonly errorPolicy?: 'hard' | 'soft' | undefined;
+    };
+  };
+  readonly entityMeta: {
+    readonly [entityKey: string]: {
+      readonly [pk: string]: {
+        readonly date: number;
+        readonly expiresAt: number;
+        readonly fetchedAt: number;
+      };
+    };
+  };
+  readonly optimistic: (
+    | previousActions.ReceiveAction
+    | previousActions.OptimisticAction
+  )[];
+  readonly lastReset: Date | number;
+}
+
+export * as legacyActions from './legacyActions.js';
+export * as newActions from './newActions.js';
+export type { SetAction } from './newActions.js';
+
+/* maintain backwards compatibility */
+/* TODO: switch to only include newActions in future */
+export type OptimisticAction<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  } = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+  },
+> = newActions.OptimisticAction<E>;
+export type InvalidateAction = newActions.InvalidateAction;
+export type ResetAction = newActions.ResetAction | legacyActions.ResetAction;
+export type GCAction = newActions.GCAction;
+export type FetchAction<
+  Payload extends object | string | number | null =
+    | object
+    | string
+    | number
+    | null,
+  S extends Schema | undefined = any,
+> = CompatibleFetchAction | legacyActions.FetchAction<Payload, S>;
+export type ReceiveAction<
+  Payload extends object | string | number | null =
+    | object
+    | string
+    | number
+    | null,
+  S extends Schema | undefined = any,
+> = CompatibleReceiveAction | legacyActions.ReceiveAction<Payload, S>;
+export type SubscribeAction =
+  | CompatibleSubscribeAction
+  | legacyActions.SubscribeAction;
+export type UnsubscribeAction =
+  | CompatibleUnsubscribeAction
+  | legacyActions.UnsubscribeAction;
+
+export type ResponseActions = ReceiveAction;
+
+// put other actions here in union
+export type OldActionTypes = previousActions.ActionTypes;
+
+export type CombinedActionTypes =
+  | OptimisticAction
+  | InvalidateAction
+  | ResetAction
+  | GCAction
+  | FetchAction
+  | ReceiveAction
+  | SubscribeAction
+  | UnsubscribeAction;
+
+export type ActionTypes = CombinedActionTypes;
+
+export interface Manager<Actions = CombinedActionTypes> {
+  getMiddleware(): Middleware<Actions>;
+  cleanup(): void;
+  init?: (state: State<any>) => void;
+}
+
+export type { Dispatch, Middleware, MiddlewareAPI };

package/ts3.4/actionTypes.d.ts

@@ -0,0 +1,11 @@
+export declare const FETCH_TYPE: "rest-hooks/fetch";
+export declare const RECEIVE_TYPE: "rest-hooks/receive";
+export declare const SET_TYPE: "rest-hooks/receive";
+export declare const OPTIMISTIC_TYPE: "rest-hooks/optimistic";
+export declare const RESET_TYPE: "rest-hooks/reset";
+export declare const SUBSCRIBE_TYPE: "rest-hooks/subscribe";
+export declare const UNSUBSCRIBE_TYPE: "rest-hook/unsubscribe";
+export declare const INVALIDATE_TYPE: "rest-hooks/invalidate";
+export declare const INVALIDATEALL_TYPE: "rest-hooks/invalidateall";
+export declare const GC_TYPE: "rest-hooks/gc";
+//# sourceMappingURL=actionTypes.d.ts.map

package/ts3.4/compatibleActions.d.ts

@@ -0,0 +1,47 @@
+import { EndpointExtraOptions, EndpointInterface, Schema } from '@data-client/normalizr';
+import { FetchAction, FetchMeta, GCAction, InvalidateAction, OptimisticAction, ReceiveActionError, ReceiveActionSuccess, ReceiveMeta, ResetAction, SubscribeAction, UnsubscribeAction } from './newActions.js';
+export interface CompatibleFetchMeta extends FetchMeta {
+    key: string;
+    schema?: Schema;
+    type: 'mutate' | 'read';
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    options?: EndpointExtraOptions;
+    optimisticResponse?: {};
+}
+export interface CompatibleFetchAction<E extends EndpointInterface = EndpointInterface> extends FetchAction<E> {
+    meta: CompatibleFetchMeta;
+}
+export interface CompatibleReceiveMeta extends ReceiveMeta {
+    key: string;
+    schema?: any;
+    update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
+    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
+}
+export interface CompatibleReceiveActionSuccess<E extends EndpointInterface = EndpointInterface> extends ReceiveActionSuccess<E> {
+    meta: CompatibleReceiveMeta;
+    payload: any;
+}
+export interface CompatibleReceiveActionError<E extends EndpointInterface = EndpointInterface> extends ReceiveActionError<E> {
+    meta: CompatibleReceiveMeta;
+    payload: any;
+}
+export type CompatibleReceiveAction<E extends EndpointInterface = EndpointInterface> = CompatibleReceiveActionSuccess<E> | CompatibleReceiveActionError<E>;
+export interface CompatibleSubscribeAction<E extends EndpointInterface = EndpointInterface> extends SubscribeAction<E> {
+    meta: {
+        args: readonly any[];
+        schema: Schema | undefined;
+        fetch: () => Promise<any>;
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+}
+export interface CompatibleUnsubscribeAction<E extends EndpointInterface = EndpointInterface> extends UnsubscribeAction<E> {
+    meta: {
+        args: readonly any[];
+        key: string;
+        options: EndpointExtraOptions | undefined;
+    };
+}
+export { OptimisticAction, InvalidateAction, ResetAction, GCAction, } from './newActions.js';
+export type CompatibleActionTypes = CompatibleFetchAction | OptimisticAction | CompatibleReceiveAction | CompatibleSubscribeAction | CompatibleUnsubscribeAction | InvalidateAction | ResetAction | GCAction;
+//# sourceMappingURL=compatibleActions.d.ts.map

package/ts3.4/controller/BaseController.d.ts

@@ -0,0 +1,170 @@
+import { ErrorTypes, SnapshotInterface, DenormalizeCache, Schema } from '@data-client/normalizr';
+import { ExpiryStatus, EndpointInterface, FetchFunction, DenormalizeNullable } from '@data-client/normalizr';
+import { EndpointUpdateFunction } from './types.js';
+import { CombinedActionTypes, State } from '../types.js';
+export type GenericDispatch = (value: any) => Promise<void>;
+export type CompatibleDispatch = (value: CombinedActionTypes) => Promise<void>;
+interface ConstructorProps<D extends GenericDispatch = CompatibleDispatch> {
+    dispatch?: D;
+    getState?: () => State<unknown>;
+    globalCache?: DenormalizeCache;
+}
+/**
+ * Imperative control of Rest Hooks store
+ * @see https://resthooks.io/docs/api/Controller
+ */
+export default class Controller<D extends GenericDispatch = CompatibleDispatch> {
+    /**
+     * Dispatches an action to Rest Hooks reducer.
+     *
+     * @see https://resthooks.io/docs/api/Controller#dispatch
+     */
+    readonly dispatch: D;
+    /**
+     * Gets the latest state snapshot that is fully committed.
+     *
+     * This can be useful for imperative use-cases like event handlers.
+     * This should *not* be used to render; instead useSuspense() or useCache()
+     * @see https://resthooks.io/docs/api/Controller#getState
+     */
+    readonly getState: () => State<unknown>;
+    readonly globalCache: DenormalizeCache;
+    constructor({ dispatch, getState, globalCache, }?: ConstructorProps<D>);
+    /*************** Action Dispatchers ***************/
+    /**
+     * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+     * @see https://resthooks.io/docs/api/Controller#invalidate
+     */
+    invalidate: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>>(endpoint: E, ...args: readonly [
+        ...Parameters<E>
+    ] | readonly [
+        null
+    ]) => Promise<void>;
+    /**
+     * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+     * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     */
+    invalidateAll: (options: {
+        testKey: (key: string) => boolean;
+    }) => Promise<void>;
+    /**
+     * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
+     * @see https://resthooks.io/docs/api/Controller#resetEntireStore
+     */
+    resetEntireStore: () => Promise<void>;
+    /**
+     * Stores response in cache for given Endpoint and args.
+     * @see https://resthooks.io/docs/api/Controller#set
+     */
+    setResponse: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [
+        ...Parameters<E>,
+        any
+    ]) => Promise<void>;
+    /**
+     * Another name for setResponse
+     * @see https://resthooks.io/docs/api/Controller#setResponse
+     */
+    receive: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [
+        ...Parameters<E>,
+        any
+    ]) => Promise<void>;
+    /**
+     * Stores the result of Endpoint and args as the error provided.
+     * @see https://resthooks.io/docs/api/Controller#setError
+     */
+    setError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [
+        ...Parameters<E>,
+        Error
+    ]) => Promise<void>;
+    /**
+     * Another name for setError
+     * @see https://resthooks.io/docs/api/Controller#setError
+     */
+    receiveError: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...rest: readonly [
+        ...Parameters<E>,
+        Error
+    ]) => Promise<void>;
+    /**
+     * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+     * @see https://resthooks.io/docs/api/Controller#resolve
+     */
+    resolve: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, meta: {
+        args: readonly [
+            ...Parameters<E>
+        ];
+        response: Error;
+        fetchedAt: number;
+        error: true;
+    } | {
+        args: readonly [
+            ...Parameters<E>
+        ];
+        response: any;
+        fetchedAt: number;
+        error?: false | undefined;
+    }) => Promise<void>;
+    /**
+     * Marks a new subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#subscribe
+     */
+    subscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
+        null
+    ] | readonly [
+        ...Parameters<E>
+    ]) => Promise<void>;
+    /**
+     * Marks completion of subscription to a given Endpoint.
+     * @see https://resthooks.io/docs/api/Controller#unsubscribe
+     */
+    unsubscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
+        null
+    ] | readonly [
+        ...Parameters<E>
+    ]) => Promise<void>;
+    /*************** More ***************/
+    /**
+     * Gets a snapshot (https://resthooks.io/docs/api/Snapshot)
+     * @see https://resthooks.io/docs/api/Controller#snapshot
+     */
+    snapshot: (state: State<unknown>, fetchedAt?: number) => SnapshotInterface;
+    /**
+     * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
+     * @see https://resthooks.io/docs/api/Controller#getError
+     */
+    getError: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "key">, Args extends readonly [
+        null
+    ] | readonly [
+        ...Parameters<E["key"]>
+    ]>(endpoint: E, ...rest: [
+        ...Args,
+        State<unknown>
+    ]) => ErrorTypes | undefined;
+    /**
+     * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+     * @see https://resthooks.io/docs/api/Controller#getResponse
+     */
+    getResponse: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "schema" | "key" | "invalidIfStale">, Args extends readonly [
+        null
+    ] | readonly [
+        ...Parameters<E["key"]>
+    ]>(endpoint: E, ...rest: [
+        ...Args,
+        State<unknown>
+    ]) => {
+        data: DenormalizeNullable<E["schema"]>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+}
+export { ErrorTypes };
+//# sourceMappingURL=BaseController.d.ts.map

package/ts3.4/controller/Controller.d.ts

@@ -0,0 +1,14 @@
+import { EndpointInterface } from '@data-client/normalizr';
+import BaseController, { CompatibleDispatch, GenericDispatch } from './BaseController.js';
+import { EndpointUpdateFunction } from './types.js';
+export default class Controller<D extends GenericDispatch = CompatibleDispatch> extends BaseController<D> {
+    /**
+     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
+     * @see https://resthooks.io/docs/api/Controller#fetch
+     */
+    fetch: <E extends EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => ReturnType<E>;
+}
+export * from './BaseController.js';
+//# sourceMappingURL=Controller.d.ts.map

package/ts3.4/controller/createFetch.d.ts

@@ -0,0 +1,14 @@
+import { EndpointInterface } from '@data-client/normalizr';
+import { EndpointUpdateFunction } from './types.js';
+import { CompatibleFetchAction } from '../compatibleActions.js';
+/**
+ * Requesting a fetch to begin
+ */
+export default function createFetch<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+}>(endpoint: E, { args }: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+}): CompatibleFetchAction<E>;
+//# sourceMappingURL=createFetch.d.ts.map

package/ts3.4/controller/createInvalidate.d.ts

@@ -0,0 +1,8 @@
+import { EndpointInterface } from '@data-client/normalizr';
+import { InvalidateAction } from '../newActions.js';
+export default function createInvalidate<E extends EndpointInterface>(endpoint: E, { args }: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+}): InvalidateAction;
+//# sourceMappingURL=createInvalidate.d.ts.map

package/ts3.4/controller/createInvalidateAll.d.ts

@@ -0,0 +1,3 @@
+import { InvalidateAllAction } from '../newActions.js';
+export default function createInvalidateAll(testKey: (key: string) => boolean): InvalidateAllAction;
+//# sourceMappingURL=createInvalidateAll.d.ts.map

package/ts3.4/controller/createOptimistic.d.ts

@@ -0,0 +1,12 @@
+import { EndpointInterface } from '@data-client/normalizr';
+import { EndpointUpdateFunction } from './types.js';
+import { OptimisticAction } from '../newActions.js';
+export default function createOptimistic<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+}>(endpoint: E, { args, fetchedAt, }: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+    fetchedAt: number;
+}): OptimisticAction<E>;
+//# sourceMappingURL=createOptimistic.d.ts.map

package/ts3.4/controller/createReceive.d.ts

@@ -0,0 +1,24 @@
+import { EndpointInterface, ResolveType } from '@data-client/normalizr';
+import { EndpointUpdateFunction } from './types.js';
+import { CompatibleReceiveAction } from '../compatibleActions.js';
+export default function createReceive<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+}>(endpoint: E, options: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+    response: Error;
+    fetchedAt?: number;
+    error: true;
+}): CompatibleReceiveAction<E>;
+export default function createReceive<E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+}>(endpoint: E, options: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+    response: ResolveType<E>;
+    fetchedAt?: number;
+    error?: false;
+}): CompatibleReceiveAction<E>;
+//# sourceMappingURL=createReceive.d.ts.map

package/ts3.4/controller/createReset.d.ts

@@ -0,0 +1,3 @@
+import { ResetAction } from '../newActions.js';
+export default function createReset(): ResetAction;
+//# sourceMappingURL=createReset.d.ts.map

package/ts3.4/controller/createSubscription.d.ts

@@ -0,0 +1,13 @@
+import { EndpointInterface } from '@data-client/normalizr';
+import { CompatibleSubscribeAction, CompatibleUnsubscribeAction } from '../compatibleActions.js';
+export declare function createSubscription<E extends EndpointInterface>(endpoint: E, { args }: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+}): CompatibleSubscribeAction<E>;
+export declare function createUnsubscription<E extends EndpointInterface>(endpoint: E, { args }: {
+    args: readonly [
+        ...Parameters<E>
+    ];
+}): CompatibleUnsubscribeAction<E>;
+//# sourceMappingURL=createSubscription.d.ts.map

package/ts3.4/controller/types.d.ts

@@ -0,0 +1,6 @@
+import { Normalize, EndpointInterface, ResolveType } from '@data-client/normalizr';
+export type ResultEntry<E extends EndpointInterface> = E['schema'] extends undefined | null ? ResolveType<E> : Normalize<E['schema']>;
+export type EndpointUpdateFunction<Source extends EndpointInterface, Updaters extends Record<string, any> = Record<string, any>> = (source: ResultEntry<Source>, ...args: any) => {
+    [K in keyof Updaters]: (result: Updaters[K]) => Updaters[K];
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,3 @@
+export { FetchShape, ReadShape, MutateShape, DeleteShape, } from './shapes.js';
+export { SetShapeParams, ParamsFromShape, OptimisticUpdateParams, SchemaFromShape, BodyFromShape, ReturnFromShape, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/endpoint/shapes.d.ts

@@ -0,0 +1,25 @@
+import { Schema, EndpointExtraOptions as FetchOptions } from '@data-client/normalizr';
+/** Defines the shape of a network request */
+export interface FetchShape<S extends Schema | undefined, Params extends Readonly<object> = Readonly<object>, Body extends Readonly<object | string> | void | unknown = Readonly<object | string> | undefined, Response = any> {
+    readonly type: 'read' | 'mutate' | 'delete';
+    fetch(params: Params, body?: Body): Promise<Response>;
+    getFetchKey(params: Params): string;
+    readonly schema: S;
+    readonly options?: FetchOptions;
+}
+/** To change values on the server */
+export interface MutateShape<S extends Schema | undefined, Params extends Readonly<object> = Readonly<object>, Body extends Readonly<object | string> | void | unknown = Readonly<object | string> | undefined, Response extends object | string | number | boolean | null = any> extends FetchShape<S, Params, Body, Response> {
+    readonly type: 'mutate';
+    fetch(params: Params, body: Body): Promise<Response>;
+}
+/** Removes entities */
+export interface DeleteShape<S extends Schema | undefined, Params extends Readonly<object> = Readonly<object>, Response extends object | string | number | boolean | null = any> extends FetchShape<S, Params, undefined, Response> {
+    readonly type: 'mutate';
+    fetch(params: Params, ...args: any): Promise<Response>;
+}
+/** For retrieval requests */
+export interface ReadShape<S extends Schema | undefined, Params extends Readonly<object> = Readonly<object>, Response extends object | string | number | boolean | null = any> extends FetchShape<S, Params, undefined, Response> {
+    readonly type: 'read';
+    fetch(params: Params): Promise<Response>;
+}
+//# sourceMappingURL=shapes.d.ts.map

package/ts3.4/endpoint/types.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from '@data-client/normalizr';
+import { Denormalize } from '@data-client/normalizr';
+import { FetchShape } from './shapes.js';
+import { UpdateFunction } from '../types.js';
+export type ResultShape<RS> = RS extends {
+    schema: infer U;
+} ? U : never;
+export type SelectReturn<RS> = RS extends {
+    select: (...args: any[]) => infer U;
+} ? U : never;
+export type AlwaysSelect<RS> = NonNullable<SelectReturn<RS>>;
+export type ParamArg<RS> = RS extends {
+    getFetchKey: (params: infer U) => any;
+} ? U : never;
+export type BodyArg<RS> = RS extends {
+    fetch: (url: any, body: infer U) => any;
+} ? U : never;
+/** Sets a FetchShape's Param type.
+ * Useful to constrain acceptable params (second arg) in hooks like useResource().
+ *
+ * @param [Shape] FetchShape to act upon
+ * @param [Params] what to set the Params to
+ */
+export type SetShapeParams<Shape extends FetchShape<any, any, any>, Params extends Readonly<object>> = {
+    [K in keyof Shape]: Shape[K];
+} & (Shape['fetch'] extends (first: any, ...rest: infer Args) => infer Return ? {
+    fetch: (first: Params, ...rest: Args) => Return;
+} : never);
+/** Get the Params type for a given Shape */
+export type ParamsFromShape<S> = S extends {
+    fetch: (first: infer A, ...rest: any) => any;
+} ? A : S extends {
+    getFetchKey: (first: infer A, ...rest: any) => any;
+} ? A : never;
+/** Get the Schema type for a given Shape */
+export type SchemaFromShape<F extends FetchShape<Schema | undefined, any, any>> = F['schema'];
+/** Get the Body type for a given Shape */
+export type BodyFromShape<F extends FetchShape<any, any, any>> = Parameters<F['fetch']>[1];
+export type OptimisticUpdateParams<SourceSchema extends Schema | undefined, DestShape extends FetchShape<any, any, any>> = [
+    DestShape,
+    ParamsFromShape<DestShape>,
+    UpdateFunction<SourceSchema, SchemaFromShape<DestShape>>
+];
+export type ReturnFromShape<S extends FetchShape<any, any, any>> = ReturnType<S['fetch']> extends unknown ? Promise<Denormalize<S['schema']>> : ReturnType<S['fetch']>;
+//# sourceMappingURL=types.d.ts.map

package/ts3.4/fsa.d.ts

@@ -0,0 +1,41 @@
+import { ErrorFluxStandardActionWithPayloadAndMeta, ErrorFluxStandardActionWithPayload, FSA } from 'flux-standard-action';
+export type ErrorableFSAWithPayloadAndMeta<Type extends string = string, Payload = undefined, Meta = undefined, CustomError extends Error = Error> = ErrorFluxStandardActionWithPayloadAndMeta<Type, CustomError, Meta> | NoErrorFluxStandardActionWithPayloadAndMeta<Type, Payload, Meta>;
+export type ErrorableFSAWithMeta<Type extends string = string, Payload = undefined, Meta = undefined, CustomError extends Error = Error> = ErrorFluxStandardActionWithPayloadAndMeta<Type, CustomError, Meta> | NoErrorFluxStandardActionWithMeta<Type, Payload, Meta>;
+export type ErrorableFSAWithPayload<Type extends string = string, Payload = undefined, Meta = undefined, CustomError extends Error = Error> = ErrorFluxStandardActionWithPayload<Type, CustomError, Meta> | NoErrorFluxStandardActionWithPayload<Type, Payload, Meta>;
+export interface NoErrorFluxStandardAction<Type extends string = string, Payload = undefined, Meta = undefined> extends FSA<Type, Payload, Meta> {
+    error?: false;
+}
+/**
+ * A Flux Standard action with a required payload property.
+ */
+export interface NoErrorFluxStandardActionWithPayload<Type extends string = string, Payload = undefined, Meta = undefined> extends NoErrorFluxStandardAction<Type, Payload, Meta> {
+    /**
+     * The required `payload` property MAY be any type of value.
+     * It represents the payload of the action.
+     * Any information about the action that is not the type or status of the action should be part of the `payload` field.
+     * By convention, if `error` is `true`, the `payload` SHOULD be an error object.
+     * This is akin to rejecting a promise with an error object.
+     */
+    payload: Payload;
+}
+/**
+ * A Flux Standard action with a required metadata property.
+ */
+export interface NoErrorFluxStandardActionWithMeta<Type extends string = string, Payload = undefined, Meta = undefined> extends NoErrorFluxStandardAction<Type, Payload, Meta> {
+    /**
+     * The required `meta` property MAY be any type of value.
+     * It is intended for any extra information that is not part of the payload.
+     */
+    meta: Meta;
+}
+/**
+ * A Flux Standard action with required payload and metadata properties.
+ */
+export type NoErrorFluxStandardActionWithPayloadAndMeta<Type extends string = string, Payload = undefined, Meta = undefined> = NoErrorFluxStandardActionWithPayload<Type, Payload, Meta> & NoErrorFluxStandardActionWithMeta<Type, Payload, Meta>;
+/**
+ * A Flux Standard action with inferred requirements for the payload and metadata properties.
+ * The `payload` and `meta` properties will be required if the corresponding type argument
+ * if not the `undefined` type.
+ */
+export type NoErrorFluxStandardActionAuto<Type extends string = string, Payload = undefined, Meta = undefined> = Payload extends undefined ? Meta extends undefined ? NoErrorFluxStandardAction<Type, Payload, Meta> : NoErrorFluxStandardActionWithMeta<Type, Payload, Meta> : Meta extends undefined ? NoErrorFluxStandardActionWithPayload<Type, Payload, Meta> : NoErrorFluxStandardActionWithPayloadAndMeta<Type, Payload, Meta>;
+//# sourceMappingURL=fsa.d.ts.map

package/ts3.4/index.d.ts

@@ -0,0 +1,22 @@
+import * as __INTERNAL__1 from './internal.js';
+export { __INTERNAL__1 as __INTERNAL__ };
+export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, ResolveType, DenormalizeCache, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, } from '@data-client/normalizr';
+export { ExpiryStatus } from '@data-client/normalizr';
+export { default as NetworkManager, ResetError, } from './manager/NetworkManager.js';
+export { default as createReducer, initialState, } from './state/reducer/createReducer.js';
+export { default as reducer } from './state/reducerInstance.js';
+export { default as applyManager } from './manager/applyManager.js';
+export { default as Controller } from './controller/Controller.js';
+export { CompatibleDispatch, GenericDispatch, } from './controller/Controller.js';
+export { default as createFetch } from './controller/createFetch.js';
+export { default as createReceive } from './controller/createReceive.js';
+export * from './controller/types.js';
+import * as legacyActions_1 from './state/legacy-actions/index.js';
+export { legacyActions_1 as legacyActions };
+import * as actionTypes_1 from './actionTypes.js';
+export { actionTypes_1 as actionTypes };
+export * from './types.js';
+export { FetchShape, ReadShape, MutateShape, DeleteShape, } from './endpoint/shapes.js';
+export { SetShapeParams, ParamsFromShape, BodyFromShape, ReturnFromShape, } from './endpoint/types.js';
+export * from './manager/index.js';
+//# sourceMappingURL=index.d.ts.map

package/ts3.4/internal.d.ts

@@ -0,0 +1,4 @@
+export { inferResults, DELETED } from '@data-client/normalizr';
+export { default as RIC } from './state/RIC.js';
+export { initialState } from './state/reducer/createReducer.js';
+//# sourceMappingURL=internal.d.ts.map