@data-client/rest 0.1.0

package/ts4.0/createResource.d.ts

@@ -0,0 +1,66 @@
+import { schema } from '@data-client/endpoint';
+import type { Schema, Denormalize, EndpointExtraOptions } from '@data-client/endpoint';
+import { PathArgs, ShortenPath } from './pathTypes.js';
+import RestEndpoint, { NewGetEndpoint, NewMutateEndpoint, RestTypeNoBody } from './RestEndpoint.js';
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+export default function createResource<U extends string, S extends Schema>({ path, schema, Endpoint, optimistic, ...extraOptions }: {
+    readonly path: U;
+    readonly schema: S;
+    readonly Endpoint?: typeof RestEndpoint;
+    urlPrefix?: string;
+    optimistic?: boolean;
+} & EndpointExtraOptions): Resource<U, S>;
+export interface Resource<U extends string, S extends Schema> {
+    /** Get a singular item
+     *
+     * @see https://resthooks.io/rest/api/createResource#get
+     */
+    get: NewGetEndpoint<{
+        path: U;
+    }, S>;
+    /** Get a list of item
+     *
+     * @see https://resthooks.io/rest/api/createResource#getlist
+     */
+    getList: NewGetEndpoint<{
+        path: ShortenPath<U>;
+        searchParams: Record<string, number | string | boolean> | undefined;
+    }, S[]>;
+    /** Create a new item (POST)
+     *
+     * @see https://resthooks.io/rest/api/createResource#create
+     */
+    create: NewMutateEndpoint<{
+        path: ShortenPath<U>;
+        body: Partial<Denormalize<S>>;
+    }, S>;
+    /** Update an item (PUT)
+     *
+     * @see https://resthooks.io/rest/api/createResource#update
+     */
+    update: NewMutateEndpoint<{
+        path: U;
+        body: Partial<Denormalize<S>>;
+    }, S>;
+    /** Update an item (PATCH)
+     *
+     * @see https://resthooks.io/rest/api/createResource#partialupdate
+     */
+    partialUpdate: NewMutateEndpoint<{
+        path: U;
+        body: Partial<Denormalize<S>>;
+    }, S>;
+    /** Delete an item (DELETE)
+     *
+     * @see https://resthooks.io/rest/api/createResource#delete
+     */
+    delete: RestTypeNoBody<PathArgs<U>, S extends schema.EntityInterface & {
+        process: any;
+    } ? schema.Delete<S> : S, undefined, Partial<PathArgs<U>>, {
+        path: U;
+    }>;
+}
+//# sourceMappingURL=createResource.d.ts.map

package/ts4.0/extractCollection.d.ts

@@ -0,0 +1,11 @@
+import { Schema, schema } from '@data-client/endpoint';
+export default function extractCollection<M extends <C extends schema.Collection>(collection: C) => any, S extends Schema | undefined>(s: S, mapper: M): ExtractCollection<S> | undefined;
+export type ExtractCollection<S extends Schema | undefined> = S extends schema.CollectionInterface ? S : S extends schema.Object<infer T> ? ExtractObject<T> : S extends Exclude<Schema, {
+    [K: string]: any;
+}> ? never : S extends {
+    [K: string]: Schema;
+} ? ExtractObject<S> : never;
+export type ExtractObject<S extends Record<string, any>> = {
+    [K in keyof S]: S[K] extends Schema ? ExtractCollection<S[K]> : never;
+}[keyof S];
+//# sourceMappingURL=extractCollection.d.ts.map

package/ts4.0/getArrayPath.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@data-client/endpoint';
+export default function getArrayPath(s: Schema | undefined): string[] | false;
+//# sourceMappingURL=getArrayPath.d.ts.map

package/ts4.0/hookifyResource.d.ts

@@ -0,0 +1,19 @@
+import { EndpointInterface } from '@data-client/endpoint';
+export interface HookableEndpointInterface extends EndpointInterface {
+  extend(...args: any): HookableEndpointInterface;
+}
+/** Turns a collection of Endpoints (Resource) into a collection of hooks.
+ * This is useful for Endpoints that need hooks to prepare their fetch requests.
+ *
+ * Requires TypeScript 4.1 to be typed correctly
+ *
+ * @see https://resthooks.io/rest/api/hookifyResource
+ */
+export default function hookifyResource<R extends {}>(
+  resource: R,
+  useRequestInit: () => RequestInit,
+): HookResource<R>;
+export type HookResource<R extends Record<string, unknown>> = {
+  [K: string]: () => R[string];
+};
+//# sourceMappingURL=hookifyResource.d.ts.map

package/ts4.0/index.d.ts

@@ -0,0 +1,12 @@
+export { default as RestEndpoint } from './RestEndpoint.js';
+export type { GetEndpoint, MutateEndpoint, NewGetEndpoint, NewMutateEndpoint, Defaults, RestGenerics, FetchGet, FetchMutate, RestFetch, RestType, RestInstance, KeyofRestEndpoint, RestEndpointConstructorOptions, AddEndpoint, PaginationFieldEndpoint, } from './RestEndpoint.js';
+export { default as createResource } from './createResource.js';
+export type { Resource } from './createResource.js';
+export { default as hookifyResource } from './hookifyResource.js';
+export type { HookResource, HookableEndpointInterface, } from './hookifyResource.js';
+export { default as NetworkError } from './NetworkError.js';
+export { default as paginationUpdate } from './paginationUpdate.js';
+export type { OptionsToFunction } from './OptionsToFunction.js';
+export type { ShortenPath, PathArgs, PathKeys, KeysToArgs, PathArgsAndSearch, } from './pathTypes.js';
+export * from '@data-client/endpoint';
+//# sourceMappingURL=index.d.ts.map

package/ts4.0/mapCollection.d.ts

@@ -0,0 +1,16 @@
+import { Schema, schema } from '@data-client/endpoint';
+export default function mapCollection<M extends <C extends schema.Collection>(collection: C) => any, S extends Schema | undefined>(s: S, mapper: M): S extends schema.Collection ? ReturnType<typeof mapper<S>> : S extends schema.Object<infer T> ? {
+    [K in keyof T]: T[K] extends Schema ? typeof mapCollection<M, T[K]> : T[K];
+} : S extends {
+    [K: string]: any;
+} ? {
+    [K in keyof S]: S[K] extends Schema ? typeof mapCollection<M, S[K]> : S[K];
+} : S;
+type MapCollection<M extends <C extends schema.Collection>(collection: C) => any, S extends Schema | undefined> = S extends schema.Collection ? ReturnType<M> : S extends schema.Object<infer T> ? MapCollection<M, T> : S extends {
+    [K: string]: any;
+} ? MapObject<M, S> : never;
+export type MapObject<M extends (collection: schema.Collection) => any, S extends Record<string, any>> = {
+    [K in keyof S]: S[K] extends Schema ? MapCollection<M, S[K]> : S[K];
+};
+export {};
+//# sourceMappingURL=mapCollection.d.ts.map

package/ts4.0/next/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/next/RestEndpoint.d.ts

@@ -0,0 +1,226 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import type { EndpointExtraOptions, EndpointInstanceInterface, Schema, FetchFunction, ResolveType, } from '@data-client/endpoint';
+import { OptionsToFunction } from './OptionsToFunction.js';
+import type { ExtractCollection } from '../extractCollection.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>): Promise<RequestInit> | RequestInit;
+    /** @see https://resthooks.io/rest/api/RestEndpoint#getHeaders */
+    getHeaders(headers: HeadersInit): Promise<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 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 Defaults<O, D> = {
+    [K in keyof O | keyof D]: K extends keyof O ? Exclude<O[K], undefined> : D[Extract<K, keyof D>];
+};
+export type GetEndpoint<O extends {
+    readonly path: string;
+    readonly schema: Schema;
+    /** Only used for types */
+    readonly searchParams?: any;
+} = {
+    path: string;
+    schema: Schema;
+}> = RestTypeNoBody<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<O['path']> : O['searchParams'] & PathArgs<O['path']> : PathArgs<O['path']>, O['schema'], undefined, any, O & {
+    body: undefined;
+}>;
+export type MutateEndpoint<O extends {
+    readonly path: string;
+    readonly schema: Schema;
+    /** Only used for types */
+    readonly searchParams?: any;
+    /** Only used for types */
+    readonly body?: any;
+} = {
+    path: string;
+    body: any;
+    schema: Schema;
+}> = RestTypeWithBody<'searchParams' extends keyof O ? O['searchParams'] extends undefined ? PathArgs<O['path']> : O['searchParams'] & PathArgs<O['path']> : PathArgs<O['path']>, O['schema'], true, O['body'], any, O>;

package/ts4.0/next/createResource.d.ts

@@ -0,0 +1,94 @@
+import { schema } from '@data-client/endpoint';
+import type { Denormalize } from '@data-client/endpoint';
+import { ResourceGenerics, ResourceOptions } from './resourceTypes.js';
+import { GetEndpoint, MutateEndpoint, RestTypeNoBody } from './RestEndpoint.js';
+import { PathArgs, ShortenPath } from '../pathTypes.js';
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+export default function createResource<O extends ResourceGenerics>({ path, schema, Endpoint, optimistic, ...extraOptions }: Readonly<O> & ResourceOptions): Resource<O>;
+export interface Resource<O extends ResourceGenerics = {
+    path: string;
+    schema: any;
+}> {
+    /** Get a singular item
+     *
+     * @see https://resthooks.io/rest/api/createResource#get
+     */
+    get: GetEndpoint<{
+        path: O['path'];
+        schema: O['schema'];
+    }>;
+    /** Get a list of item
+     *
+     * @see https://resthooks.io/rest/api/createResource#getlist
+     */
+    getList: 'searchParams' extends keyof O ? GetEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>;
+        searchParams: O['searchParams'];
+    }> : GetEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>;
+        searchParams: Record<string, number | string | boolean> | undefined;
+    }>;
+    /** Create a new item (POST)
+     *
+     * @see https://resthooks.io/rest/api/createResource#create
+     */
+    create: 'searchParams' extends keyof O ? MutateEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>['push'];
+        body: 'body' extends keyof O ? O['body'] : Partial<Denormalize<O['schema']>>;
+        searchParams: O['searchParams'];
+    }> : MutateEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>['push'];
+        body: 'body' extends keyof O ? O['body'] : Partial<Denormalize<O['schema']>>;
+    }>;
+    /** Update an item (PUT)
+     *
+     * @see https://resthooks.io/rest/api/createResource#update
+     */
+    update: 'body' extends keyof O ? MutateEndpoint<{
+        path: O['path'];
+        body: O['body'];
+        schema: O['schema'];
+    }> : MutateEndpoint<{
+        path: O['path'];
+        body: Partial<Denormalize<O['schema']>>;
+        schema: O['schema'];
+    }>;
+    /** Update an item (PATCH)
+     *
+     * @see https://resthooks.io/rest/api/createResource#partialupdate
+     */
+    partialUpdate: 'body' extends keyof O ? MutateEndpoint<{
+        path: O['path'];
+        body: Partial<O['body']>;
+        schema: O['schema'];
+    }> : MutateEndpoint<{
+        path: O['path'];
+        body: Partial<Denormalize<O['schema']>>;
+        schema: O['schema'];
+    }>;
+    /** Delete an item (DELETE)
+     *
+     * @see https://resthooks.io/rest/api/createResource#delete
+     */
+    delete: RestTypeNoBody<PathArgs<O['path']>, O['schema'] extends schema.EntityInterface & {
+        process: any;
+    } ? schema.Invalidate<O['schema']> : O['schema'], undefined, Partial<PathArgs<O['path']>>, {
+        path: O['path'];
+    }>;
+}
+//# sourceMappingURL=createResource.d.ts.map

package/ts4.0/next/index.d.ts

@@ -0,0 +1,6 @@
+export * from './RestEndpoint.js';
+export { default as RestEndpoint } from './RestEndpoint.js';
+export { default as createResource } from './createResource.js';
+export type { Resource } from './createResource.js';
+export type { ResourceOptions, ResourceGenerics } from './resourceTypes.js';
+//# sourceMappingURL=index.d.ts.map

package/ts4.0/next/resourceTypes.d.ts

@@ -0,0 +1,31 @@
+import type { Schema } from '@data-client/endpoint';
+import RestEndpoint from './RestEndpoint.js';
+export interface ResourceGenerics {
+    readonly path: string;
+    readonly schema: Schema;
+    /** Only used for types */
+    readonly body?: any;
+    /** Only used for types */
+    readonly searchParams?: any;
+}
+export interface ResourceOptions {
+    Endpoint?: typeof RestEndpoint;
+    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>;
+    /** Default data expiry length, will fall back to NetworkManager default if not defined */
+    readonly dataExpiryLength?: number;
+    /** Default error expiry length, will fall back to NetworkManager default if not defined */
+    readonly errorExpiryLength?: number;
+    /** Poll with at least this frequency in miliseconds */
+    readonly pollFrequency?: number;
+    /** Marks cached resources as invalid if they are stale */
+    readonly invalidIfStale?: boolean;
+    /** Determines whether to throw or fallback to */
+    errorPolicy?(error: any): 'hard' | 'soft' | undefined;
+    optimistic?: boolean;
+}
+//# sourceMappingURL=resourceTypes.d.ts.map

package/ts4.0/paginatedCollections.d.ts

@@ -0,0 +1,3 @@
+export declare function paginatedMerge(existing: any[], incoming: any[]): any[];
+export declare const paginatedFilter: <C extends (...args: readonly any[]) => readonly any[]>(removeCursor: C) => (...args: Parameters<C>) => (collectionKey: Record<string, string>) => boolean;
+//# sourceMappingURL=paginatedCollections.d.ts.map

package/ts4.0/paginationUpdate.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from '@data-client/endpoint';
+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>
+]): (newPage: any, ...args: A) => {
+    [x: number]: (existing: any) => any;
+};
+//# sourceMappingURL=paginationUpdate.d.ts.map

package/ts4.0/paramsToString.d.ts

@@ -0,0 +1,2 @@
+export default function paramsToString(searchParams: Readonly<Record<string, string | number | boolean>>): string;
+//# sourceMappingURL=paramsToString.d.ts.map

package/ts4.0/paramsToString.native.d.ts

@@ -0,0 +1,2 @@
+export default function paramsToString(searchParams: Readonly<Record<string, string | number>>): string;
+//# sourceMappingURL=paramsToString.native.d.ts.map

package/ts4.0/pathTypes.d.ts

@@ -0,0 +1,20 @@
+/** Computes the union of keys for a path string */
+export declare type PathKeys<S extends string> = string;
+
+/** Parameters for a given path */
+export declare type PathArgs<S extends string> = PathKeys<S> extends never
+  ? unknown
+  : KeysToArgs<PathKeys<S>>;
+
+export declare type KeysToArgs<Key extends string> = {
+  [K in Key]?: string | number;
+};
+export declare type PathArgsAndSearch<S extends string> =
+  PathKeys<S> extends never
+    ? Record<string, number | string> | undefined
+    : {
+        [K in PathKeys<S>]: string | number;
+      } & Record<string, number | string>;
+
+/** Removes the last :token */
+export declare type ShortenPath<S extends string> = S;