@data-client/core 0.1.0 → 0.2.1

package/src/state/legacy-actions/createFetch.ts

@@ -1,95 +0,0 @@
-// TODO(breaking): remove file - not used
-import { Schema } from '@data-client/normalizr';
-
-import { FETCH_TYPE } from '../../actionTypes.js';
-import {
-  FetchShape,
-  SchemaFromShape,
-  ParamsFromShape,
-  BodyFromShape,
-  OptimisticUpdateParams,
-} from '../../endpoint/index.js';
-import { FetchAction } from '../../legacyActions.js';
-
-interface Options<
-  Shape extends FetchShape<
-    Schema | undefined,
-    Readonly<object>,
-    Readonly<object | string> | void
-  >,
-> {
-  params: ParamsFromShape<Shape>;
-  body?: BodyFromShape<Shape>;
-  throttle: boolean;
-  updateParams?:
-    | OptimisticUpdateParams<
-        SchemaFromShape<Shape>,
-        FetchShape<Schema | undefined, any, any>
-      >[]
-    | undefined;
-}
-
-/** Requesting a fetch to begin
- *
- * @param fetchShape
- * @param param1 { params, body, throttle, updateParams }
- */
-export default function createFetch<
-  Shape extends FetchShape<
-    Schema | undefined,
-    Readonly<object>,
-    Readonly<object | string> | void
-  >,
->(
-  fetchShape: Shape & {
-    update?: (...args: any) => Record<string, (...args: any) => any>;
-  },
-  { params, body, throttle, updateParams }: Options<Shape>,
-): FetchAction {
-  const { schema, type, getFetchKey, options } = fetchShape;
-
-  const key = getFetchKey(params);
-  let resolve: (value?: any | PromiseLike<any>) => void = 0 as any;
-  let reject: (reason?: any) => void = 0 as any;
-  const promise = new Promise<any>((a, b) => {
-    [resolve, reject] = [a, b];
-  });
-  const meta: FetchAction['meta'] = {
-    schema,
-    type,
-    args: [params, body],
-    key,
-    throttle,
-    options,
-    resolve,
-    reject,
-    promise,
-    createdAt: Date.now(),
-  };
-
-  if (fetchShape.update) {
-    meta.update = fetchShape.update;
-  }
-
-  // for simplicity we simply override if updateParams are defined - usage together is silly to support as we are migrating
-  if (updateParams) {
-    meta.update = (newresult: any): Record<string, (...args: any) => any> => {
-      const updateMap: any = {};
-      updateParams.forEach(([toShape, toParams, updateFn]) => {
-        updateMap[toShape.getFetchKey(toParams)] = (existing: any) =>
-          updateFn(newresult, existing);
-      });
-      return updateMap;
-    };
-  }
-
-  if (options?.optimisticUpdate) {
-    meta.optimisticResponse = options.optimisticUpdate(params, body);
-  }
-
-  return {
-    type: FETCH_TYPE,
-    payload: () => fetchShape.fetch(params, body),
-    meta,
-  };
-}

package/src/state/legacy-actions/createReceive.ts

@@ -1,68 +0,0 @@
-import type {
-  Schema,
-  EndpointExtraOptions as FetchOptions,
-} from '@data-client/normalizr';
-
-import { RECEIVE_TYPE } from '../../actionTypes.js';
-import { FetchAction, ReceiveAction } from '../../legacyActions.js';
-
-interface Options<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
-> extends Pick<
-    FetchAction<Payload, S>['meta'],
-    'schema' | 'key' | 'type' | 'updaters' | 'update' | 'args'
-  > {
-  dataExpiryLength: NonNullable<FetchOptions['dataExpiryLength']>;
-  fetchedAt?: number;
-}
-
-/** Update state with data
- *
- * @param data
- * @param param1 { schema, key, type, updaters, dataExpiryLength }
- */
-export default function createReceive<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
->(
-  data: Payload,
-  {
-    schema,
-    key,
-    args,
-    updaters,
-    fetchedAt = 0,
-    update,
-    dataExpiryLength,
-  }: Options<Payload, S>,
-): ReceiveAction<Payload, S> {
-  /* istanbul ignore next */
-  if (process.env.NODE_ENV === 'development' && dataExpiryLength < 0) {
-    throw new Error('Negative dataExpiryLength are not allowed.');
-  }
-  const now = Date.now();
-  const meta: ReceiveAction['meta'] = {
-    schema,
-    key,
-    args,
-    date: now,
-    fetchedAt,
-    expiresAt: now + dataExpiryLength,
-  };
-  meta.updaters = updaters;
-  meta.update = update;
-  return {
-    type: RECEIVE_TYPE,
-    payload: data,
-    meta,
-  };
-}

package/src/state/legacy-actions/createReceiveError.ts

@@ -1,43 +0,0 @@
-import {
-  Schema,
-  EndpointExtraOptions as FetchOptions,
-} from '@data-client/normalizr';
-
-import { RECEIVE_TYPE } from '../../actionTypes.js';
-import { FetchAction, ReceiveAction } from '../../legacyActions.js';
-
-interface Options<S extends Schema | undefined = any>
-  extends Pick<FetchAction<any, S>['meta'], 'schema' | 'key' | 'options'> {
-  errorExpiryLength?: NonNullable<FetchOptions['errorExpiryLength']>;
-  fetchedAt?: number;
-}
-
-export default function createReceiveError<S extends Schema | undefined = any>(
-  error: Error,
-  {
-    schema,
-    key,
-    options,
-    errorExpiryLength = 60000,
-    fetchedAt = 0,
-  }: Options<S>,
-): ReceiveAction {
-  /* istanbul ignore next */
-  if (process.env.NODE_ENV === 'development' && errorExpiryLength < 0) {
-    throw new Error('Negative errorExpiryLength are not allowed.');
-  }
-  const now = Date.now();
-  return {
-    type: RECEIVE_TYPE,
-    payload: error,
-    meta: {
-      schema,
-      key,
-      date: now,
-      fetchedAt,
-      expiresAt: now + errorExpiryLength,
-      errorPolicy: options?.errorPolicy,
-    },
-    error: true,
-  };
-}

package/src/state/legacy-actions/index.ts

@@ -1,3 +0,0 @@
-export { default as createFetch } from './createFetch.js';
-export { default as createReceive } from './createReceive.js';
-export { default as createReceiveError } from './createReceiveError.js';

package/src/state/reducerInstance.ts

@@ -1,14 +0,0 @@
-/* istanbul ignore file */
-import createReducer from './reducer/createReducer.js';
-import Controller from '../controller/Controller.js';
-import { ActionTypes, State } from '../types.js';
-
-/**
- * @deprecated use createReducer instead
- */
-const reducer: (
-  state: State<unknown> | undefined,
-  action: ActionTypes,
-) => State<unknown> = createReducer(new Controller());
-
-export default reducer;

package/ts3.4/compatibleActions.d.ts

@@ -1,47 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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/endpoint/index.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/legacyActions.d.ts

@@ -1,95 +0,0 @@
-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/next/Controller.d.ts

@@ -1,14 +0,0 @@
-import { EndpointInterface, Denormalize } from '@data-client/normalizr';
-import BaseController, { CompatibleDispatch, GenericDispatch } from '../controller/BaseController.js';
-import { EndpointUpdateFunction } from '../controller/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>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
-}
-export * from '../controller/BaseController.js';
-//# sourceMappingURL=Controller.d.ts.map