@data-client/rest 0.1.0

package/src/paginatedCollections.ts

@@ -0,0 +1,32 @@
+export function paginatedMerge(existing: any[], incoming: any[]) {
+  const existingSet: Set<string> = new Set(existing);
+  const mergedList = [...existing];
+  for (const pk of incoming) {
+    if (!existingSet.has(pk)) mergedList.push(pk);
+  }
+  return mergedList;
+}
+export const paginatedFilter =
+  <C extends (...args: readonly any[]) => readonly any[]>(removeCursor: C) =>
+  (...args: Parameters<C>) => {
+    const noCursorArgs = removeCursor(...args);
+    return (collectionKey: Record<string, string>) =>
+      shallowEqual(collectionKey, noCursorArgs[0] ?? {});
+  };
+
+function shallowEqual(
+  object1: Record<string, any>,
+  object2: Record<string, any>,
+) {
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (object1[key] != object2[key]) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/paginationUpdate.ts

@@ -0,0 +1,49 @@
+import { Schema } from '@data-client/endpoint';
+
+import getArrayPath from './getArrayPath.js';
+
+export default function paginationUpdate<
+  E extends { schema: Schema; key: any } & ((...args: any) => Promise<any>),
+  A extends any[],
+>(
+  endpoint: E,
+  removeCursor: (...args: A) => readonly [...Parameters<typeof endpoint>],
+) {
+  // infer path from schema. if schema is undefined assume array is top level
+  const path = getArrayPath(endpoint.schema);
+  if (path === false) throw new Error('schema has no array');
+
+  return (newPage: any, ...args: A) => ({
+    [endpoint.key(...(removeCursor(...args) as any))]: (existing: any) => {
+      const existingList = getIn(existing, path);
+      // using set so our lookups are O(1) in case this is large
+      const existingSet: Set<string> = new Set(existingList);
+      const addedList = getIn(newPage, path).filter(
+        (pk: string) => !existingSet.has(pk),
+      );
+      const mergedResults: string[] = [...existingList, ...addedList];
+      return setIn(newPage, path, mergedResults);
+    },
+  });
+}
+
+const getIn = (results: any, path: string[]): any[] => {
+  let cur = results;
+  for (const p of path) {
+    if (!cur) return [];
+    cur = cur[p];
+  }
+  return cur || [];
+};
+
+const setIn = <T>(results: T, path: string[], values: any[]): T => {
+  if (path.length === 0) return values as any;
+  const newResults = { ...results };
+  let cur: any = newResults;
+  for (let i = 0; i < path.length - 1; i++) {
+    const p = path[i];
+    cur = cur[p] = { ...cur[p] };
+  }
+  cur[path[path.length - 1]] = values;
+  return newResults;
+};

package/src/paramsToString.native.ts

@@ -0,0 +1,10 @@
+export default function paramsToString(
+  searchParams: Readonly<Record<string, string | number>>,
+) {
+  const params = new URLSearchParams(searchParams as any);
+  try {
+    params.sort();
+    // eslint-disable-next-line no-empty
+  } catch {}
+  return params.toString();
+}

package/src/paramsToString.ts

@@ -0,0 +1,7 @@
+export default function paramsToString(
+  searchParams: Readonly<Record<string, string | number | boolean>>,
+) {
+  const params = new URLSearchParams(searchParams as any);
+  params.sort();
+  return params.toString();
+}

package/src/pathTypes.ts

@@ -0,0 +1,58 @@
+type OnlyOptional<S extends string> = S extends `${infer K}?` ? K : never;
+type OnlyRequired<S extends string> = S extends `${string}?` ? never : S;
+
+/** Computes the union of keys for a path string */
+export type PathKeys<S extends string> = string extends S
+  ? string
+  : S extends `${infer A}\\:${infer B}`
+  ? PathKeys<A> | PathKeys<B>
+  : S extends `${infer A}\\?${infer B}`
+  ? PathKeys<A> | PathKeys<B>
+  : PathSplits<S>;
+
+type PathSplits<S extends string> = S extends `${string}:${infer K}${
+  | '/'
+  | ','
+  | '%'
+  | '&'}${infer R}`
+  ? PathSplits<`:${K}`> | PathSplits<R>
+  : S extends `${string}:${infer K}:${infer R}`
+  ? PathSplits<`:${K}`> | PathSplits<`:${R}`>
+  : S extends `${string}:${infer K}`
+  ? K
+  : never;
+
+/** Parameters for a given path */
+export type PathArgs<S extends string> = PathKeys<S> extends never
+  ? // unknown is identity for intersection ('&')
+    unknown
+  : KeysToArgs<PathKeys<S>>;
+
+export type KeysToArgs<Key extends string> = {
+  [K in Key as OnlyOptional<K>]?: string | number;
+} & (OnlyRequired<Key> extends never
+  ? unknown
+  : {
+      [K in Key as OnlyRequired<K>]: string | number;
+    });
+
+export type PathArgsAndSearch<S extends string> = OnlyRequired<
+  PathKeys<S>
+> extends never
+  ? Record<string, number | string | boolean> | undefined
+  : {
+      [K in PathKeys<S> as OnlyRequired<K>]: string | number;
+    } & Record<string, number | string>;
+
+/** Removes the last :token */
+export type ShortenPath<S extends string> = string extends S
+  ? string
+  : S extends `${infer B}:${infer R}`
+  ? TrimColon<`${B}:${ShortenPath<R>}`>
+  : '';
+
+type TrimColon<S extends string> = string extends S
+  ? string
+  : S extends `${infer R}:`
+  ? R
+  : S;

package/src/test-fixtures.ts

@@ -0,0 +1,128 @@
+export const payload = {
+  id: 5,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react'],
+};
+
+export const createPayload = {
+  id: 1,
+  title: 'hi ho',
+  content: 'whatever',
+  tags: ['a', 'best', 'react'],
+};
+
+export const articlesPages = {
+  prevPage: '23asdl',
+  nextPage: 's3f3',
+  results: [
+    {
+      id: 23,
+      title: 'the first draft',
+      content: 'the best things in life com efree',
+      tags: ['one', 'two'],
+    },
+    {
+      id: 44,
+      title: 'the second book',
+      content: 'the best things in life com efree',
+      tags: ['hbh', 'wew'],
+    },
+    {
+      id: 2,
+      title: 'the third novel',
+      content: 'the best things in life com efree',
+      tags: ['free', 'honey'],
+    },
+    {
+      id: 643,
+      title: 'a long time ago',
+      content: 'the best things in life com efree',
+    },
+  ],
+};
+
+export const users = [
+  {
+    id: 23,
+    username: 'bob',
+    email: 'bob@bob.com',
+    isAdmin: false,
+  },
+  {
+    id: 7342,
+    username: 'lindsey',
+    email: 'lindsey@bob.com',
+    isAdmin: true,
+  },
+];
+
+export const nested = [
+  {
+    id: 5,
+    title: 'hi ho',
+    content: 'whatever',
+    tags: ['a', 'best', 'react'],
+    author: {
+      id: 23,
+      username: 'bob',
+    },
+  },
+  {
+    id: 3,
+    title: 'the next time',
+    content: 'whatever',
+    author: {
+      id: 23,
+      username: 'charles',
+      email: 'bob@bob.com',
+    },
+  },
+];
+
+export const moreNested = [
+  {
+    id: 7,
+    title: 'article 7',
+    content: 'whatever',
+    tags: ['blah'],
+    author: {
+      id: 23,
+      username: 'bob',
+    },
+  },
+  {
+    id: 8,
+    title: 'article 8',
+    content: 'whatever',
+    author: {
+      id: 27,
+      username: 'zac',
+      email: 'zac@bob.com',
+    },
+  },
+];
+
+export const valuesFixture = {
+  first: {
+    id: 1,
+    title: 'first thing',
+    content: 'blah',
+    tags: [],
+  },
+  second: {
+    id: 2,
+    name: 'second thing',
+    content: 'blah',
+    tags: [],
+  },
+};
+
+export const paginatedFirstPage = {
+  nextPage: '2',
+  data: { results: nested },
+};
+
+export const paginatedSecondPage = {
+  data: { results: moreNested },
+};

package/src/utiltypes.ts

@@ -0,0 +1,25 @@
+/** Extracts only the keys that will be required
+ *
+ * Removes optional, as well as unbounded (aka 'string')
+ *
+ * @example
+ ```
+RequiredKeys<{
+  opt?: string;
+  bob: string;
+  alice: number;
+  [k: string]: string | number | undefined;
+}> // = 'bob' | 'alice'
+ ```
+ */
+export type RequiredKeys<T> = Values<OnlyRequired<T>>;
+
+type OnlyRequired<T> = {
+  [K in keyof T as string extends K ? never : K]-?: {} extends Pick<T, K>
+    ? never
+    : K;
+};
+
+// exclude number only required for typescript 4.4 and below
+// https://www.typescriptlang.org/play?ts=4.4.4#code/C4TwDgpgBAglC8UDeUBGB7VAuKBnYATgJYB2A5gNxQDaA1jvseQLo4CsAPo6WVAL4UAsACgRIiAA8w6AsCihIUAEoQAjgFciBCABMA0hBC4APABUAfAigA1AIYAbdRBMB5EvZAqNW3WfPmhUWFJaVl5cGg3Dy9NbR0-KyQRKBo9KFIoWkN0ADMoUyhbXDxCHihJYAgSHWK0gH4oEggANwgCKBw9ZgBaOpwkPnKJSurigAUiAGNaMwAaKD1zZJSoBqbWgmWUzsCBMWEFaDtHZwTEUzpsvNNmQJFDqABhKyjPNVjfGCWDiKgAIT+ViyIFyT3uv0ez0QxycJke5iAA
+type Values<T> = T[Exclude<keyof T, number>];

package/ts4.0/NetworkError.d.ts

@@ -0,0 +1,11 @@
+/** An error with a Rest Endpoint fetch
+ *
+ * @see https://resthooks.io/rest/api/NetworkError
+ */
+export default class NetworkError extends Error {
+    status: number;
+    response: Response;
+    name: string;
+    constructor(response: Response);
+}
+//# sourceMappingURL=NetworkError.d.ts.map

package/ts4.0/OptionsToFunction.d.ts

@@ -0,0 +1,16 @@
+import type { FetchFunction, ResolveType } from '@data-client/endpoint';
+
+import { PartialRestGenerics, RestInstance } from './RestEndpoint.js';
+
+export type OptionsToFunction<
+  O extends PartialRestGenerics,
+  E extends RestInstance & {
+    body?: any;
+  },
+  F extends FetchFunction,
+> = (
+  this: ThisParameterType<F>,
+  ...args: any
+) => Promise<
+  O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>
+>;

package/ts4.0/RestEndpoint.d.ts

@@ -0,0 +1,240 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { EndpointExtraOptions, EndpointInstanceInterface, Schema, FetchFunction, ResolveType, } from '@data-client/endpoint';
+import type { ExtractCollection } from './extractCollection.js';
+import { OptionsToFunction } from './OptionsToFunction.js';
+import { PathArgs } from './pathTypes.js';
+import { EndpointUpdateFunction } from './RestEndpointTypeHelp.js';
+export interface RestInstanceBase<F extends FetchFunction = FetchFunction, S extends Schema | undefined = any, M extends true | undefined = true | undefined, O extends {
+    path: string;
+    body?: any;
+    searchParams?: any;
+} = {
+    path: string;
+}> extends EndpointInstanceInterface<F, S, M> {
+    readonly body?: 'body' extends keyof O ? O['body'] : any;
+    readonly searchParams?: 'searchParams' extends keyof O ? O['searchParams'] : unknown;
+    /** Pattern to construct url based on Url Parameters
+     * @see https://resthooks.io/rest/api/RestEndpoint#path
+     */
+    readonly path: O['path'];
+    /** Prepended to all urls
+     * @see https://resthooks.io/rest/api/RestEndpoint#urlPrefix
+     */
+    readonly urlPrefix: string;
+    readonly requestInit: RequestInit;
+    readonly method: string;
+    readonly signal: AbortSignal | undefined;
+    /* fetch lifecycles */
+    /* before-fetch */
+    url(...args: Parameters<F>): string;
+    /** @see https://resthooks.io/rest/api/RestEndpoint#getRequestInit */
+    getRequestInit(this: any, body?: RequestInit['body'] | Record<string, unknown>): RequestInit;
+    /** @see https://resthooks.io/rest/api/RestEndpoint#getHeaders */
+    getHeaders(headers: HeadersInit): HeadersInit;
+    /* after-fetch */
+    /** @see https://resthooks.io/rest/api/RestEndpoint#fetchResponse */
+    fetchResponse(input: RequestInfo, init: RequestInit): Promise<Response>;
+    /** @see https://resthooks.io/rest/api/RestEndpoint#parseResponse */
+    parseResponse(response: Response): Promise<any>;
+    /** @see https://resthooks.io/rest/api/RestEndpoint#process */
+    process(value: any, ...args: Parameters<F>): ResolveType<F>;
+    /* utilities */
+    /** @see https://resthooks.io/rest/api/RestEndpoint#testKey */
+    testKey(key: string): boolean;
+    /* extenders */
+    // TODO: figure out better way than wrapping whole options in Readonly<> + making O extend from {}
+    //       this is just a hack to handle when no members of PartialRestGenerics are present
+    //       Note: Using overloading (like paginated did) struggles because typescript does not have a clear way of distinguishing one
+    //       should be used from the other (due to same problem with every member being partial)
+    extend<E extends RestInstanceBase, O extends PartialRestGenerics | {}>(this: E, options: Readonly<RestEndpointExtendOptions<O, E, F> & O>): RestExtendedEndpoint<O, E>;
+    paginated<E extends RestInstanceBase<FetchFunction, any, undefined>, A extends any[]>(this: E, removeCursor: (...args: A) => readonly [
+        ...Parameters<E>
+    ]): PaginationEndpoint<E, A>;
+    paginated<E extends RestInstanceBase<FetchFunction, any, undefined>, C extends string>(this: E, cursorField: C): PaginationFieldEndpoint<E, C>;
+}
+export interface RestInstance<F extends FetchFunction = FetchFunction, S extends Schema | undefined = any, M extends true | undefined = true | undefined, O extends {
+    path: string;
+    body?: any;
+    searchParams?: any;
+} = {
+    path: string;
+}> extends RestInstanceBase<F, S, M, O> {
+    push: AddEndpoint<F, S, O>;
+    unshift: AddEndpoint<F, S, O>;
+    assign: AddEndpoint<F, S, O>;
+}
+export type ContainsCollectionArray = {
+    push: any;
+    unshift: any;
+} | {
+    [K: string]: ContainsCollectionArray;
+} | {
+    schema: {
+        [K: string]: ContainsCollectionArray;
+    };
+};
+export type ContainsCollectionValues = {
+    assign: any;
+} | {
+    [K: string]: ContainsCollectionValues;
+} | {
+    schema: {
+        [K: string]: ContainsCollectionValues;
+    };
+};
+export type RestEndpointExtendOptions<O extends PartialRestGenerics, E extends RestInstanceBase, F extends FetchFunction> = RestEndpointOptions<OptionsToFunction<O, E, F>, 'schema' extends keyof O ? Extract<O['schema'], Schema | undefined> : E['schema']> & Partial<Omit<E, KeyofRestEndpoint | keyof PartialRestGenerics>>;
+type OptionsToRestEndpoint<O extends PartialRestGenerics, E extends RestInstanceBase & {
+    body?: any;
+}, F extends FetchFunction> = 'path' extends keyof O ? RestType<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<Exclude<O['path'], undefined>> : O['searchParams'] & PathArgs<Exclude<O['path'], undefined>> : PathArgs<Exclude<O['path'], undefined>>, 'body' extends keyof O ? O['body'] : E['body'], 'schema' extends keyof O ? O['schema'] : E['schema'], 'method' extends keyof O ? MethodToSide<O['method']> : E['sideEffect'], O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>, {
+    path: Exclude<O['path'], undefined>;
+    body: 'body' extends keyof O ? O['body'] : E['body'];
+    searchParams: 'searchParams' extends keyof O ? O['searchParams'] : E['searchParams'];
+}> : 'body' extends keyof O ? RestType<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<Exclude<O['path'], undefined>> : O['searchParams'] & PathArgs<Exclude<E['path'], undefined>> : PathArgs<Exclude<E['path'], undefined>>, O['body'], 'schema' extends keyof O ? O['schema'] : E['schema'], 'method' extends keyof O ? MethodToSide<O['method']> : E['sideEffect'], O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>, {
+    path: E['path'];
+    body: O['body'];
+    searchParams: 'searchParams' extends keyof O ? O['searchParams'] : E['searchParams'];
+}> : 'searchParams' extends keyof O ? RestType<O['searchParams'] extends undefined ? PathArgs<Exclude<O['path'], undefined>> : O['searchParams'] & PathArgs<Exclude<E['path'], undefined>>, E['body'], 'schema' extends keyof O ? O['schema'] : E['schema'], 'method' extends keyof O ? MethodToSide<O['method']> : E['sideEffect'], O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>, {
+    path: E['path'];
+    body: E['body'];
+    searchParams: O['searchParams'];
+}> : RestInstance<F, 'schema' extends keyof O ? O['schema'] : E['schema'], 'method' extends keyof O ? MethodToSide<O['method']> : E['sideEffect'], {
+    path: 'path' extends keyof O ? Exclude<O['path'], undefined> : E['path'];
+    body: 'body' extends keyof O ? O['body'] : E['body'];
+    searchParams: 'searchParams' extends keyof O ? O['searchParams'] : E['searchParams'];
+}>;
+export type RestExtendedEndpoint<O extends PartialRestGenerics, E extends RestInstanceBase> = OptionsToRestEndpoint<O, E, RestInstance<(...args: Parameters<E>) => O['process'] extends {} ? Promise<ReturnType<O['process']>> : ReturnType<E>, 'schema' extends keyof O ? O['schema'] : E['schema'], 'method' extends keyof O ? MethodToSide<O['method']> : E['sideEffect']>> & Omit<O, KeyofRestEndpoint> & Omit<E, KeyofRestEndpoint | keyof O>;
+export interface PartialRestGenerics {
+    readonly path?: string;
+    readonly schema?: Schema | undefined;
+    readonly method?: string;
+    /** Only used for types */
+    readonly body?: any;
+    /** Only used for types */
+    readonly searchParams?: any;
+    /** @see https://resthooks.io/rest/api/RestEndpoint#process */
+    process?(value: any, ...args: any): any;
+}
+export interface RestGenerics extends PartialRestGenerics {
+    readonly path: string;
+}
+export type PaginationEndpoint<E extends RestInstanceBase, A extends any[]> = RestInstance<ParamFetchNoBody<A[0], ResolveType<E>>, E['schema'], E['sideEffect'], Pick<E, 'path' | 'searchParams' | 'body'> & {
+    searchParams: Omit<A[0], keyof PathArgs<E['path']>>;
+}>;
+export type PaginationFieldEndpoint<E extends RestInstanceBase, C extends string> = RestInstance<ParamFetchNoBody<{
+    [K in C]: string | number | boolean;
+} & E['searchParams'] & PathArgs<Exclude<E['path'], undefined>>, ResolveType<E>>, E['schema'], E['sideEffect'], Pick<E, 'path' | 'searchParams' | 'body'> & {
+    searchParams: {
+        [K in C]: string | number | boolean;
+    } & E['searchParams'];
+}>;
+export type AddEndpoint<F extends FetchFunction = FetchFunction, S extends Schema | undefined = any, O extends {
+    path: string;
+    body?: any;
+    searchParams?: any;
+} = {
+    path: string;
+}> = RestInstanceBase<RestFetch<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<Exclude<O['path'], undefined>> : O['searchParams'] & PathArgs<Exclude<O['path'], undefined>> : PathArgs<Exclude<O['path'], undefined>>, any, ReturnType<F>>, ExtractCollection<S>, true, Omit<O, 'body'>> & {
+    method: 'POST';
+};
+export type BodyDefault<O extends RestGenerics> = 'body' extends keyof O ? O['body'] : O['method'] extends 'POST' | 'PUT' | 'PATCH' ? Record<string, unknown> | FormData : undefined;
+type OptionsBodyDefault<O extends RestGenerics> = 'body' extends keyof O ? O : O['method'] extends 'POST' | 'PUT' | 'PATCH' ? O & {
+    body: any;
+} : O & {
+    body: undefined;
+};
+export interface RestEndpointOptions<F extends FetchFunction = FetchFunction, S extends Schema | undefined = undefined> extends EndpointExtraOptions<F> {
+    urlPrefix?: string;
+    requestInit?: RequestInit;
+    getHeaders?(headers: HeadersInit): Promise<HeadersInit> | HeadersInit;
+    getRequestInit?(body: any): Promise<RequestInit> | RequestInit;
+    fetchResponse?(input: RequestInfo, init: RequestInit): Promise<any>;
+    parseResponse?(response: Response): Promise<any>;
+    sideEffect?: true | undefined;
+    name?: string;
+    signal?: AbortSignal;
+    fetch?: F;
+    key?(...args: Parameters<F>): string;
+    url?(...args: Parameters<F>): string;
+    update?: EndpointUpdateFunction<F, S>;
+}
+export type RestEndpointConstructorOptions<O extends RestGenerics = any> = RestEndpointOptions<RestFetch<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<O['path']> : O['searchParams'] & PathArgs<O['path']> : PathArgs<O['path']>, BodyDefault<O>, O['process'] extends {} ? ReturnType<O['process']> : any /*Denormalize<O['schema']>*/>, O['schema']>;
+export interface RestEndpointConstructor {
+    new <O extends RestGenerics = any>({ method, sideEffect, name, ...options }: RestEndpointConstructorOptions<O> & Readonly<O>): RestInstance<RestFetch<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<O['path']> : O['searchParams'] & PathArgs<O['path']> : PathArgs<O['path']>, BodyDefault<O>, O['process'] extends {} ? ReturnType<O['process']> : any /*Denormalize<O['schema']>*/>, 'schema' extends keyof O ? O['schema'] : undefined, MethodToSide<O['method']>, OptionsBodyDefault<O>>;
+    readonly prototype: RestInstanceBase;
+}
+/** Simplifies endpoint definitions that follow REST patterns
+ *
+ * @see https://resthooks.io/rest/api/RestEndpoint
+ */
+export declare let RestEndpoint: RestEndpointConstructor;
+export default RestEndpoint;
+export type MethodToSide<M> = M extends string ? M extends 'GET' ? undefined : true : undefined;
+/** RestEndpoint types simplified */
+export type RestType<UrlParams = any, Body = any, S extends Schema | undefined = Schema | undefined, M extends true | undefined = true | undefined, R = any, O extends {
+    path: string;
+    body?: any;
+    searchParams?: any;
+} = {
+    path: string;
+}> = IfTypeScriptLooseNull<RestInstance<keyof UrlParams extends never ? (this: EndpointInstanceInterface, body?: Body) => Promise<R> : {} extends UrlParams ? ((this: EndpointInstanceInterface, body?: Body) => Promise<R>) | ((this: EndpointInstanceInterface, params: UrlParams, body?: Body) => Promise<R>) : (this: EndpointInstanceInterface, params: UrlParams, body?: Body) => Promise<R>, S, M, O>, Body extends {} ? RestTypeWithBody<UrlParams, S, M, Body, R, O> : RestTypeNoBody<UrlParams, S, M, R, O>>;
+export type RestTypeWithBody<UrlParams = any, S extends Schema | undefined = Schema | undefined, M extends true | undefined = true | undefined, Body = any, R = any /*Denormalize<S>*/, O extends {
+    path: string;
+    body?: any;
+    searchParams?: any;
+} = {
+    path: string;
+    body: any;
+}> = RestInstance<ParamFetchWithBody<UrlParams, Body, R>, S, M, O>;
+export type RestTypeNoBody<UrlParams = any, S extends Schema | undefined = Schema | undefined, M extends true | undefined = true | undefined, R = any /*Denormalize<S>*/, O extends {
+    path: string;
+    body?: undefined;
+    searchParams?: any;
+} = {
+    path: string;
+    body: undefined;
+}> = RestInstance<ParamFetchNoBody<UrlParams, R>, S, M, O>;
+/** Simple parameters, and body fetch functions */
+export type RestFetch<UrlParams, 
+// eslint-disable-next-line @typescript-eslint/ban-types
+Body = {}, Resolve = any> = IfTypeScriptLooseNull<ParamFetchNoBody<UrlParams, Resolve> | ParamFetchWithBody<UrlParams, Body, Resolve>, Body extends {} ? ParamFetchWithBody<UrlParams, Body, Resolve> : ParamFetchNoBody<UrlParams, Resolve>>;
+export type ParamFetchWithBody<P, B = {}, R = any> = 
+// we must always allow undefined in a union and give it a type without params
+P extends undefined ? (this: EndpointInstanceInterface, body: B) => Promise<R> : {} extends P ? keyof P extends never ? (this: EndpointInstanceInterface, body: B) => Promise<R> : ((this: EndpointInstanceInterface, params: P, body: B) => Promise<R>) | ((this: EndpointInstanceInterface, body: B) => Promise<R>) : (this: EndpointInstanceInterface, params: P, body: B) => Promise<R>;
+export type ParamFetchNoBody<P, R = any> = 
+// we must always allow undefined in a union and give it a type without params
+P extends undefined ? (this: EndpointInstanceInterface) => Promise<R> : {} extends P ? keyof P extends never ? (this: EndpointInstanceInterface) => Promise<R> : ((this: EndpointInstanceInterface, params: P) => Promise<R>) | ((this: EndpointInstanceInterface) => Promise<R>) : (this: EndpointInstanceInterface, params: P) => Promise<R>;
+type IfTypeScriptLooseNull<Y, N> = 1 | undefined extends 1 ? Y : N;
+export type KeyofRestEndpoint = keyof RestInstance;
+export type FromFallBack<K extends keyof E, O, E> = K extends keyof O ? O[K] : E[K];
+export type FetchMutate<A extends readonly any[] = [
+    any,
+    {}
+]
+// eslint-disable-next-line @typescript-eslint/ban-types
+ | [
+    {}
+], R = any> = (this: RestInstance, ...args: A) => Promise<R>;
+export type FetchGet<A extends readonly any[] = [
+    any
+], R = any> = (this: RestInstance, ...args: A) => Promise<R>;
+export type GetEndpoint<UrlParams = any, S extends Schema | undefined = Schema | undefined> = RestTypeNoBody<UrlParams, S, undefined>;
+export type MutateEndpoint<UrlParams = any, Body extends BodyInit | Record<string, any> = any, S extends Schema | undefined = Schema | undefined> = RestTypeWithBody<UrlParams, S, true, Body>;
+export type Defaults<O, D> = {
+    [K in keyof O | keyof D]: K extends keyof O ? Exclude<O[K], undefined> : D[Extract<K, keyof D>];
+};
+export type NewGetEndpoint<O extends {
+    path: string;
+    searchParams?: any;
+} = {
+    path: string;
+}, S extends Schema | undefined = Schema | undefined> = RestTypeNoBody<'searchParams' extends keyof O ? O['searchParams'] & PathArgs<O['path']> : PathArgs<O['path']>, S, undefined, any, O & {
+    body: undefined;
+}>;
+export type NewMutateEndpoint<O extends {
+    path: string;
+    body?: any;
+    searchParams?: any;
+} = {
+    path: string;
+    body: any;
+}, S extends Schema | undefined = Schema | undefined> = RestTypeWithBody<'searchParams' extends keyof O ? O['searchParams'] & PathArgs<O['path']> : PathArgs<O['path']>, S, true, O['body'], any, O>;

package/ts4.0/RestEndpointTypeHelp.d.ts

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

package/ts4.0/RestHelpers.d.ts

@@ -0,0 +1,7 @@
+import { PathFunction } from 'path-to-regexp';
+import { ShortenPath } from './pathTypes.js';
+export declare function getUrlBase(path: string): PathFunction;
+export declare function getUrlTokens(path: string): Set<string>;
+export declare function isPojo(obj: unknown): obj is Record<string, any>;
+export declare function shortenPath<S extends string>(path: S): ShortenPath<S>;
+//# sourceMappingURL=RestHelpers.d.ts.map