@spoosh/angular 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Spoosh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,229 @@
+# @spoosh/angular
+
+Angular signals integration for Spoosh - `injectRead`, `injectWrite`, and `injectInfiniteRead`.
+
+**[Documentation](https://spoosh.dev/docs/integrations/angular)** · **Requirements:** TypeScript >= 5.0, Angular >= 16.0
+
+## Installation
+
+```bash
+npm install @spoosh/core @spoosh/angular
+```
+
+## Usage
+
+### Setup
+
+```typescript
+import { Spoosh } from "@spoosh/core";
+import { createAngularSpoosh } from "@spoosh/angular";
+import { cachePlugin } from "@spoosh/plugin-cache";
+
+const spoosh = new Spoosh<ApiSchema, Error>("/api").use([
+  cachePlugin({ staleTime: 5000 }),
+]);
+
+export const { injectRead, injectWrite, injectInfiniteRead } =
+  createAngularSpoosh(spoosh);
+```
+
+### injectRead
+
+Fetch data with automatic caching and refetching using Angular signals.
+
+```typescript
+@Component({
+  template: `
+    @if (users.loading()) {
+      <div>Loading...</div>
+    } @else if (users.error()) {
+      <div>Error: {{ users.error()?.message }}</div>
+    } @else {
+      <ul>
+        @for (user of users.data(); track user.id) {
+          <li>{{ user.name }}</li>
+        }
+      </ul>
+    }
+  `,
+})
+export class UserListComponent {
+  users = injectRead((api) => api.users.$get());
+}
+
+// With options
+@Component({ ... })
+export class UserListComponent {
+  isReady = signal(false);
+
+  // Recommended: Pass signal directly (shorter syntax)
+  users = injectRead(
+    (api) => api.users.$get({ query: { page: 1 } }),
+    {
+      staleTime: 10000,
+      enabled: this.isReady,
+    }
+  );
+
+  // Also works: Arrow function wrapper
+  // enabled: () => this.isReady(),
+}
+```
+
+### injectWrite
+
+Trigger mutations with loading and error states.
+
+```typescript
+@Component({
+  template: `
+    <form (ngSubmit)="handleSubmit()">
+      <input [(ngModel)]="title" />
+      <button [disabled]="createUser.loading()">
+        {{ createUser.loading() ? "Creating..." : "Create User" }}
+      </button>
+    </form>
+  `,
+})
+export class CreateUserComponent {
+  title = signal("");
+
+  createUser = injectWrite((api) => api.users.$post);
+
+  async handleSubmit() {
+    const result = await this.createUser.trigger({
+      body: { name: this.title() },
+    });
+
+    if (result.data) {
+      // Success
+    }
+  }
+}
+```
+
+### injectInfiniteRead
+
+Bidirectional paginated data fetching with infinite scroll support.
+
+```typescript
+@Component({
+  template: `
+    @if (posts.canFetchPrev()) {
+      <button (click)="posts.fetchPrev()" [disabled]="posts.fetchingPrev()">
+        {{ posts.fetchingPrev() ? "Loading..." : "Load Previous" }}
+      </button>
+    }
+
+    @for (post of posts.data(); track post.id) {
+      <app-post-card [post]="post" />
+    }
+
+    @if (posts.canFetchNext()) {
+      <button (click)="posts.fetchNext()" [disabled]="posts.fetchingNext()">
+        {{ posts.fetchingNext() ? "Loading..." : "Load More" }}
+      </button>
+    }
+  `,
+})
+export class PostListComponent {
+  posts = injectInfiniteRead((api) => api.posts.$get({ query: { page: 1 } }), {
+    // Required: Check if next page exists
+    canFetchNext: ({ response }) => response?.meta.hasMore ?? false,
+
+    // Required: Build request for next page
+    nextPageRequest: ({ response, request }) => ({
+      query: { ...request.query, page: (response?.meta.page ?? 0) + 1 },
+    }),
+
+    // Required: Merge all responses into items
+    merger: (allResponses) => allResponses.flatMap((r) => r.items),
+
+    // Optional: Check if previous page exists
+    canFetchPrev: ({ response }) => (response?.meta.page ?? 1) > 1,
+
+    // Optional: Build request for previous page
+    prevPageRequest: ({ response, request }) => ({
+      query: { ...request.query, page: (response?.meta.page ?? 2) - 1 },
+    }),
+  });
+}
+```
+
+## API Reference
+
+### injectRead(readFn, options?)
+
+| Option           | Type                                          | Default | Description                          |
+| ---------------- | --------------------------------------------- | ------- | ------------------------------------ |
+| `enabled`        | `boolean \| Signal<boolean> \| () => boolean` | `true`  | Whether to fetch automatically       |
+| `staleTime`      | `number`                                      | -       | Cache stale time (from plugin-cache) |
+| `retries`        | `number`                                      | -       | Retry attempts (from plugin-retry)   |
+| + plugin options | -                                             | -       | Options from installed plugins       |
+
+**Returns:**
+
+| Property   | Type                          | Description                               |
+| ---------- | ----------------------------- | ----------------------------------------- |
+| `data`     | `Signal<TData \| undefined>`  | Response data                             |
+| `error`    | `Signal<TError \| undefined>` | Error if request failed                   |
+| `loading`  | `Signal<boolean>`             | True during initial load                  |
+| `fetching` | `Signal<boolean>`             | True during any fetch                     |
+| `meta`     | `Signal<PluginResults>`       | Plugin metadata (e.g., `transformedData`) |
+| `refetch`  | `() => Promise`               | Manually trigger refetch                  |
+| `abort`    | `() => void`                  | Abort current request                     |
+
+### injectWrite(writeFn)
+
+**Returns:**
+
+| Property  | Type                          | Description                        |
+| --------- | ----------------------------- | ---------------------------------- |
+| `trigger` | `(options) => Promise`        | Execute the mutation               |
+| `data`    | `Signal<TData \| undefined>`  | Response data                      |
+| `error`   | `Signal<TError \| undefined>` | Error if request failed            |
+| `loading` | `Signal<boolean>`             | True while mutation is in progress |
+| `meta`    | `Signal<PluginResults>`       | Plugin metadata                    |
+| `input`   | `TriggerOptions \| undefined` | Last trigger input                 |
+| `reset`   | `() => void`                  | Reset state                        |
+| `abort`   | `() => void`                  | Abort current request              |
+
+### injectInfiniteRead(readFn, options)
+
+| Option            | Type                                          | Required | Description                     |
+| ----------------- | --------------------------------------------- | -------- | ------------------------------- |
+| `canFetchNext`    | `(ctx) => boolean`                            | Yes      | Check if next page exists       |
+| `nextPageRequest` | `(ctx) => Partial<TRequest>`                  | Yes      | Build request for next page     |
+| `merger`          | `(allResponses) => TItem[]`                   | Yes      | Merge all responses into items  |
+| `canFetchPrev`    | `(ctx) => boolean`                            | No       | Check if previous page exists   |
+| `prevPageRequest` | `(ctx) => Partial<TRequest>`                  | No       | Build request for previous page |
+| `enabled`         | `boolean \| Signal<boolean> \| () => boolean` | No       | Whether to fetch automatically  |
+
+**Context object passed to callbacks:**
+
+```typescript
+type Context<TData, TRequest> = {
+  response: TData | undefined; // Latest response
+  allResponses: TData[]; // All fetched responses
+  request: TRequest; // Current request options
+};
+```
+
+**Returns:**
+
+| Property       | Type                           | Description                     |
+| -------------- | ------------------------------ | ------------------------------- |
+| `data`         | `Signal<TItem[] \| undefined>` | Merged items from all responses |
+| `allResponses` | `Signal<TData[] \| undefined>` | Array of all raw responses      |
+| `loading`      | `Signal<boolean>`              | True during initial load        |
+| `fetching`     | `Signal<boolean>`              | True during any fetch           |
+| `fetchingNext` | `Signal<boolean>`              | True while fetching next page   |
+| `fetchingPrev` | `Signal<boolean>`              | True while fetching previous    |
+| `canFetchNext` | `Signal<boolean>`              | Whether next page exists        |
+| `canFetchPrev` | `Signal<boolean>`              | Whether previous page exists    |
+| `meta`         | `Signal<PluginResults>`        | Plugin metadata                 |
+| `fetchNext`    | `() => Promise<void>`          | Fetch the next page             |
+| `fetchPrev`    | `() => Promise<void>`          | Fetch the previous page         |
+| `refetch`      | `() => Promise<void>`          | Refetch all pages               |
+| `abort`        | `() => void`                   | Abort current request           |
+| `error`        | `Signal<TError \| undefined>`  | Error if request failed         |

package/dist/index.d.mts

@@ -0,0 +1,358 @@
+import * as _spoosh_core from '@spoosh/core';
+import { PluginArray, StateManager, EventEmitter, PluginExecutor, QueryOnlyClient, MethodOptionsMap, CoreRequestOptionsBase, SpooshResponse, MutationOnlyClient, SpooshPlugin, PluginTypeConfig, InfiniteRequestOptions, ResolveTypes, ResolverContext, ResolveResultTypes, MergePluginInstanceApi } from '@spoosh/core';
+import { Signal } from '@angular/core';
+
+interface SpooshInstanceShape<TApi, TSchema, TDefaultError, TPlugins extends PluginArray> {
+    api: TApi;
+    stateManager: StateManager;
+    eventEmitter: EventEmitter;
+    pluginExecutor: PluginExecutor;
+    _types: {
+        schema: TSchema;
+        defaultError: TDefaultError;
+        plugins: TPlugins;
+    };
+}
+type EnabledOption = boolean | (() => boolean);
+interface BaseReadOptions {
+    enabled?: EnabledOption;
+    tags?: string[];
+    additionalTags?: string[];
+}
+interface BaseReadResult<TData, TError, TPluginResult = Record<string, unknown>> {
+    data: Signal<TData | undefined>;
+    error: Signal<TError | undefined>;
+    loading: Signal<boolean>;
+    fetching: Signal<boolean>;
+    meta: Signal<TPluginResult>;
+    abort: () => void;
+    refetch: () => Promise<SpooshResponse<TData, TError>>;
+}
+interface BaseWriteResult<TData, TError, TOptions, TPluginResult = Record<string, unknown>> {
+    trigger: (options?: TOptions) => Promise<SpooshResponse<TData, TError>>;
+    data: Signal<TData | undefined>;
+    error: Signal<TError | undefined>;
+    loading: Signal<boolean>;
+    meta: Signal<TPluginResult>;
+    reset: () => void;
+    abort: () => void;
+}
+type PageContext<TData, TRequest> = {
+    response: TData | undefined;
+    allResponses: TData[];
+    request: TRequest;
+};
+interface BaseInfiniteReadOptions<TData, TItem, TRequest> extends BaseReadOptions {
+    canFetchNext: (ctx: PageContext<TData, TRequest>) => boolean;
+    canFetchPrev?: (ctx: PageContext<TData, TRequest>) => boolean;
+    nextPageRequest: (ctx: PageContext<TData, TRequest>) => Partial<TRequest>;
+    prevPageRequest?: (ctx: PageContext<TData, TRequest>) => Partial<TRequest>;
+    merger: (responses: TData[]) => TItem[];
+}
+interface BaseInfiniteReadResult<TData, TError, TItem, TPluginResult = Record<string, unknown>> {
+    data: Signal<TItem[] | undefined>;
+    allResponses: Signal<TData[] | undefined>;
+    error: Signal<TError | undefined>;
+    loading: Signal<boolean>;
+    fetching: Signal<boolean>;
+    fetchingNext: Signal<boolean>;
+    fetchingPrev: Signal<boolean>;
+    canFetchNext: Signal<boolean>;
+    canFetchPrev: Signal<boolean>;
+    meta: Signal<TPluginResult>;
+    fetchNext: () => Promise<void>;
+    fetchPrev: () => Promise<void>;
+    refetch: () => Promise<void>;
+    abort: () => void;
+}
+type QueryRequestOptions = CoreRequestOptionsBase;
+type MutationRequestOptions = CoreRequestOptionsBase;
+type AngularOptionsMap = MethodOptionsMap<QueryRequestOptions, MutationRequestOptions>;
+type ReadApiClient<TSchema, TDefaultError> = QueryOnlyClient<TSchema, TDefaultError, AngularOptionsMap>;
+type WriteApiClient<TSchema, TDefaultError> = MutationOnlyClient<TSchema, TDefaultError, AngularOptionsMap>;
+type QueryField<TQuery> = [TQuery] extends [never] ? object : {
+    query: TQuery;
+};
+type BodyField<TBody> = [TBody] extends [never] ? object : {
+    body: TBody;
+};
+type FormDataField<TFormData> = [TFormData] extends [never] ? object : {
+    formData: TFormData;
+};
+type ParamsField<TParamNames extends string> = [TParamNames] extends [never] ? object : {
+    params: Record<TParamNames, string | number>;
+};
+type ReadInputFields<TQuery, TBody, TFormData, TParamNames extends string> = QueryField<TQuery> & BodyField<TBody> & FormDataField<TFormData> & ParamsField<TParamNames>;
+type ResponseInputFields<TQuery, TBody, TFormData, TParamNames extends string> = [TQuery, TBody, TFormData, TParamNames] extends [never, never, never, never] ? object : {
+    input: ReadInputFields<TQuery, TBody, TFormData, TParamNames>;
+};
+type OptionalQueryField<TQuery> = [TQuery] extends [never] ? object : {
+    query: TQuery;
+};
+type OptionalBodyField<TBody> = [TBody] extends [never] ? object : {
+    body: TBody;
+};
+type OptionalFormDataField<TFormData> = [TFormData] extends [never] ? object : {
+    formData: TFormData;
+};
+type OptionalParamsField<TParamNames extends string> = [TParamNames] extends [
+    never
+] ? object : {
+    params: Record<TParamNames, string | number>;
+};
+type InputFields<TQuery, TBody, TFormData, TParamNames extends string> = OptionalQueryField<TQuery> & OptionalBodyField<TBody> & OptionalFormDataField<TFormData> & OptionalParamsField<TParamNames>;
+type WriteResponseInputFields<TQuery, TBody, TFormData, TParamNames extends string> = [TQuery, TBody, TFormData, TParamNames] extends [never, never, never, never] ? object : {
+    input: Signal<InputFields<TQuery, TBody, TFormData, TParamNames> | undefined>;
+};
+type SuccessResponse<T> = Extract<T, {
+    data: unknown;
+    error?: undefined;
+}>;
+type ErrorResponse<T> = Extract<T, {
+    error: unknown;
+    data?: undefined;
+}>;
+type ExtractMethodData<T> = T extends (...args: never[]) => infer R ? SuccessResponse<Awaited<R>> extends {
+    data: infer D;
+} ? D : unknown : unknown;
+type ExtractMethodError<T> = T extends (...args: never[]) => infer R ? ErrorResponse<Awaited<R>> extends {
+    error: infer E;
+} ? E : unknown : unknown;
+type ExtractMethodOptions<T> = T extends (options?: infer O) => Promise<unknown> ? O : never;
+type AwaitedReturnType<T> = T extends (...args: never[]) => infer R ? Awaited<R> : never;
+type SuccessReturnType<T> = SuccessResponse<AwaitedReturnType<T>>;
+type ExtractResponseQuery<T> = SuccessReturnType<T> extends {
+    input: {
+        query: infer Q;
+    };
+} ? Q : never;
+type ExtractResponseBody<T> = SuccessReturnType<T> extends {
+    input: {
+        body: infer B;
+    };
+} ? B : never;
+type ExtractResponseFormData<T> = SuccessReturnType<T> extends {
+    input: {
+        formData: infer F;
+    };
+} ? F : never;
+type ExtractResponseParamNames<T> = SuccessReturnType<T> extends {
+    input: {
+        params: Record<infer K, unknown>;
+    };
+} ? K extends string ? K : never : never;
+type ExtractMethodQuery<T> = ExtractMethodOptions<T> extends {
+    query: infer Q;
+} ? Q : never;
+type ExtractMethodBody<T> = ExtractMethodOptions<T> extends {
+    body: infer B;
+} ? B : never;
+type ExtractMethodFormData<T> = ExtractMethodOptions<T> extends {
+    formData: infer F;
+} ? F : never;
+type ExtractMethodUrlEncoded<T> = ExtractMethodOptions<T> extends {
+    urlEncoded: infer U;
+} ? U : never;
+
+type AnyInfiniteRequestOptions = InfiniteRequestOptions;
+declare function createInjectInfiniteRead<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TReadFn extends (api: ReadApiClient<TSchema, TDefaultError>) => Promise<SpooshResponse<unknown, unknown>>, TRequest extends AnyInfiniteRequestOptions = AnyInfiniteRequestOptions, TReadOpts extends BaseInfiniteReadOptions<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, unknown, TRequest> & ResolveTypes<((TPlugins[number] extends infer T_3 ? T_3 extends TPlugins[number] ? T_3 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) extends infer T_4 ? T_4 extends (TPlugins[number] extends infer T_5 ? T_5 extends TPlugins[number] ? T_5 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) ? T_4 extends unknown ? (x: T_4) => void : never : never : never) extends (x: infer I_1) => void ? I_1 : never, ResolverContext<TSchema, TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown>> = BaseInfiniteReadOptions<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, unknown, TRequest> & ResolveTypes<((TPlugins[number] extends infer T_6 ? T_6 extends TPlugins[number] ? T_6 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) extends infer T_7 ? T_7 extends (TPlugins[number] extends infer T_8 ? T_8 extends TPlugins[number] ? T_8 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) ? T_7 extends unknown ? (x: T_7) => void : never : never : never) extends (x: infer I_1) => void ? I_1 : never, ResolverContext<TSchema, TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown>>>(readFn: TReadFn, readOptions: TReadOpts) => BaseInfiniteReadResult<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, TReadOpts extends {
+    merger: (...args: never[]) => (infer I)[];
+} ? I : unknown, ResolveResultTypes<((TPlugins[number] extends infer T ? T extends TPlugins[number] ? T extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    readResult: infer R_2;
+} ? R_2 : object : object : never : never) extends infer T_1 ? T_1 extends (TPlugins[number] extends infer T_2 ? T_2 extends TPlugins[number] ? T_2 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    readResult: infer R_2;
+} ? R_2 : object : object : never : never) ? T_1 extends unknown ? (x: T_1) => void : never : never : never) extends (x: infer I_1) => void ? I_1 : never, TReadOpts>>;
+
+declare function createInjectWrite<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TMethod extends (...args: never[]) => Promise<SpooshResponse<unknown, unknown>>, TWriteOpts extends (TMethod extends (...args: infer A) => unknown ? A[0] : never) & _spoosh_core.ResolveTypes<((TPlugins[number] extends infer T_3 ? T_3 extends TPlugins[number] ? T_3 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    writeOptions: infer W_1;
+} ? W_1 : object : object : never : never) extends infer T_4 ? T_4 extends (TPlugins[number] extends infer T_5 ? T_5 extends TPlugins[number] ? T_5 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    writeOptions: infer W_1;
+} ? W_1 : object : object : never : never) ? T_4 extends unknown ? (x: T_4) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TMethod extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TMethod extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TMethod extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, ExtractMethodQuery<TMethod>, ExtractMethodBody<TMethod>, ExtractResponseParamNames<TMethod> extends never ? never : Record<ExtractResponseParamNames<TMethod>, string | number>, ExtractMethodFormData<TMethod>, never>> = (TMethod extends (...args: infer A) => unknown ? A[0] : never) & _spoosh_core.ResolveTypes<((TPlugins[number] extends infer T_6 ? T_6 extends TPlugins[number] ? T_6 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    writeOptions: infer W_1;
+} ? W_1 : object : object : never : never) extends infer T_7 ? T_7 extends (TPlugins[number] extends infer T_8 ? T_8 extends TPlugins[number] ? T_8 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    writeOptions: infer W_1;
+} ? W_1 : object : object : never : never) ? T_7 extends unknown ? (x: T_7) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TMethod extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TMethod extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TMethod extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, ExtractMethodQuery<TMethod>, ExtractMethodBody<TMethod>, ExtractResponseParamNames<TMethod> extends never ? never : Record<ExtractResponseParamNames<TMethod>, string | number>, ExtractMethodFormData<TMethod>, never>>>(writeFn: (api: WriteApiClient<TSchema, TDefaultError>) => TMethod) => BaseWriteResult<TMethod extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TMethod extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TMethod extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, TWriteOpts, ResolveResultTypes<((TPlugins[number] extends infer T ? T extends TPlugins[number] ? T extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    writeResult: infer W;
+} ? W : object : object : never : never) extends infer T_1 ? T_1 extends (TPlugins[number] extends infer T_2 ? T_2 extends TPlugins[number] ? T_2 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    writeResult: infer W;
+} ? W : object : object : never : never) ? T_1 extends unknown ? (x: T_1) => void : never : never : never) extends (x: infer I) => void ? I : never, TWriteOpts>> & WriteResponseInputFields<ExtractResponseQuery<TMethod>, ExtractResponseBody<TMethod>, ExtractResponseFormData<TMethod>, ExtractResponseParamNames<TMethod>>;
+
+declare function createInjectRead<TSchema, TDefaultError, TPlugins extends readonly SpooshPlugin<PluginTypeConfig>[]>(options: Omit<SpooshInstanceShape<unknown, TSchema, TDefaultError, TPlugins>, "_types">): <TReadFn extends (api: ReadApiClient<TSchema, TDefaultError>) => Promise<{
+    data?: unknown;
+    error?: unknown;
+}>, TReadOpts extends BaseReadOptions & ResolveTypes<((TPlugins[number] extends infer T_3 ? T_3 extends TPlugins[number] ? T_3 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) extends infer T_4 ? T_4 extends (TPlugins[number] extends infer T_5 ? T_5 extends TPlugins[number] ? T_5 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) ? T_4 extends unknown ? (x: T_4) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown>> = BaseReadOptions & ResolveTypes<((TPlugins[number] extends infer T_6 ? T_6 extends TPlugins[number] ? T_6 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) extends infer T_7 ? T_7 extends (TPlugins[number] extends infer T_8 ? T_8 extends TPlugins[number] ? T_8 extends SpooshPlugin<infer Types_1 extends PluginTypeConfig> ? Types_1 extends {
+    readOptions: infer R_3;
+} ? R_3 : object : object : never : never) ? T_7 extends unknown ? (x: T_7) => void : never : never : never) extends (x: infer I) => void ? I : never, ResolverContext<TSchema, TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown>>>(readFn: TReadFn, readOptions?: TReadOpts) => BaseReadResult<TReadFn extends (...args: never[]) => infer R ? Extract<Awaited<R>, {
+    data: unknown;
+    error?: undefined;
+}> extends {
+    data: infer D;
+} ? D : unknown : unknown, [TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown] extends [unknown] ? TDefaultError : TReadFn extends (...args: never[]) => infer R_1 ? Extract<Awaited<R_1>, {
+    error: unknown;
+    data?: undefined;
+}> extends {
+    error: infer E;
+} ? E : unknown : unknown, ResolveResultTypes<((TPlugins[number] extends infer T ? T extends TPlugins[number] ? T extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    readResult: infer R_2;
+} ? R_2 : object : object : never : never) extends infer T_1 ? T_1 extends (TPlugins[number] extends infer T_2 ? T_2 extends TPlugins[number] ? T_2 extends SpooshPlugin<infer Types extends PluginTypeConfig> ? Types extends {
+    readResult: infer R_2;
+} ? R_2 : object : object : never : never) ? T_1 extends unknown ? (x: T_1) => void : never : never : never) extends (x: infer I) => void ? I : never, TReadOpts>> & ResponseInputFields<ExtractResponseQuery<TReadFn>, ExtractResponseBody<TReadFn>, ExtractResponseFormData<TReadFn>, ExtractResponseParamNames<TReadFn>>;
+
+type SpooshAngularFunctions<TDefaultError, TSchema, TPlugins extends PluginArray> = {
+    injectRead: ReturnType<typeof createInjectRead<TSchema, TDefaultError, TPlugins>>;
+    injectWrite: ReturnType<typeof createInjectWrite<TSchema, TDefaultError, TPlugins>>;
+    injectInfiniteRead: ReturnType<typeof createInjectInfiniteRead<TSchema, TDefaultError, TPlugins>>;
+} & MergePluginInstanceApi<TPlugins, TSchema>;
+
+declare function createAngularSpoosh<TSchema, TDefaultError, TPlugins extends PluginArray, TApi>(instance: SpooshInstanceShape<TApi, TSchema, TDefaultError, TPlugins>): SpooshAngularFunctions<TDefaultError, TSchema, TPlugins>;
+
+export { type AngularOptionsMap, type BaseInfiniteReadOptions, type BaseInfiniteReadResult, type BaseReadOptions, type BaseReadResult, type BaseWriteResult, type EnabledOption, type ExtractMethodBody, type ExtractMethodData, type ExtractMethodError, type ExtractMethodFormData, type ExtractMethodOptions, type ExtractMethodQuery, type ExtractMethodUrlEncoded, type ExtractResponseBody, type ExtractResponseFormData, type ExtractResponseParamNames, type ExtractResponseQuery, type PageContext, type ReadApiClient, type ResponseInputFields, type SpooshInstanceShape, type WriteApiClient, type WriteResponseInputFields, createAngularSpoosh };