@kanda-libs/kai-frontend-services 0.0.1

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@kanda-libs/kai-frontend-services",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.esm.js",
+  "types": "src/index.d.ts",
+  "module": "dist/index.esm.js",
+  "type": "module",
+  "files": [
+    "dist",
+    "src/**/*.d.ts"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@openapi-io-ts/cli": "^0.5.0",
+    "@openapi-io-ts/runtime": "^0.3.1",
+    "@reduxjs/toolkit": "^2.2.3",
+    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
+    "@types/node": "^20.11.24",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "esbuild": "^0.20.2",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-react": "^7.33.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.5",
+    "eslint-plugin-unused-imports": "^3.1.0",
+    "fp-ts": "^2.16.5",
+    "io-ts": "^2.2.21",
+    "io-ts-types": "^0.5.19",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.3",
+    "vite": "^5.2.8"
+  },
+  "engines": {
+    "node": ">=18.19.0"
+  },
+  "scripts": {
+    "build:service-module": "node --no-warnings=ExperimentalWarning --experimental-specifier-resolution=node --loader ts-node/esm src/codegen/service/generator/index.ts",
+    "build:store": "node --no-warnings=ExperimentalWarning --experimental-specifier-resolution=node --loader ts-node/esm src/codegen/store/generator/index.ts",
+    "build:types": "tsc src/index.ts --declaration --emitDeclarationOnly --jsx react-jsx --esModuleInterop --module esnext --moduleResolution node",
+    "build:esm": "pnpm run build:service-module && pnpm run build:store && pnpm run build:types && node --no-warnings=ExperimentalWarning --experimental-specifier-resolution=node --loader ts-node/esm ./build.ts"
+  }
+}

package/src/codegen/generated/components/schemas/Address.d.ts

@@ -0,0 +1,18 @@
+import * as t from 'io-ts';
+export declare const Address: t.IntersectionC<[t.TypeC<{
+    line_1: t.StringC;
+    city: t.StringC;
+    country: t.StringC;
+}>, t.PartialC<{
+    line_2: t.StringC;
+    county: t.StringC;
+    postcode: t.StringC;
+}>]>;
+export interface Address {
+    line_1: string;
+    line_2?: string;
+    city: string;
+    county?: string;
+    country: string;
+    postcode?: string;
+}

package/src/codegen/generated/components/schemas/Error.d.ts

@@ -0,0 +1,9 @@
+import * as t from 'io-ts';
+export declare const Error: t.TypeC<{
+    code: t.NumberC;
+    message: t.StringC;
+}>;
+export interface Error {
+    code: number;
+    message: string;
+}

package/src/codegen/generated/components/schemas/GenerateType.d.ts

@@ -0,0 +1,3 @@
+import * as t from 'io-ts';
+export declare const GenerateType: t.UnionC<[t.LiteralC<"job_quote">, t.LiteralC<"public_liability_insurance">]>;
+export type GenerateType = 'job_quote' | 'public_liability_insurance';

package/src/codegen/generated/components/schemas/JobQuote.d.ts

@@ -0,0 +1,49 @@
+import * as t from 'io-ts';
+import { LineItem } from './LineItem';
+import { Money } from './Money';
+import { Recipient } from './Recipient';
+export declare const JobQuote: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+    title: t.StringC;
+    items: t.ArrayC<t.IntersectionC<[t.TypeC<{
+        unit: t.NumberC;
+        unit_price: t.TypeC<{
+            pence: t.NumberC;
+            currency: t.LiteralC<"GBP">;
+            vat: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        summary: t.StringC;
+    }>]>>;
+    total_price: t.TypeC<{
+        pence: t.NumberC;
+        currency: t.LiteralC<"GBP">;
+        vat: t.StringC;
+    }>;
+}>, t.PartialC<{
+    description: t.StringC;
+    category: t.StringC;
+    recipient: t.TypeC<{
+        name: t.StringC;
+        email: t.StringC;
+        mobile: t.StringC;
+        address: t.IntersectionC<[t.TypeC<{
+            line_1: t.StringC;
+            city: t.StringC;
+            country: t.StringC;
+        }>, t.PartialC<{
+            line_2: t.StringC;
+            county: t.StringC;
+            postcode: t.StringC;
+        }>]>;
+    }>;
+}>]>;
+export interface JobQuote {
+    id: string;
+    title: string;
+    description?: string;
+    category?: string;
+    recipient?: Recipient;
+    items: Array<LineItem>;
+    total_price: Money;
+}

package/src/codegen/generated/components/schemas/LineItem.d.ts

@@ -0,0 +1,17 @@
+import * as t from 'io-ts';
+import { Money } from './Money';
+export declare const LineItem: t.IntersectionC<[t.TypeC<{
+    unit: t.NumberC;
+    unit_price: t.TypeC<{
+        pence: t.NumberC;
+        currency: t.LiteralC<"GBP">;
+        vat: t.StringC;
+    }>;
+}>, t.PartialC<{
+    summary: t.StringC;
+}>]>;
+export interface LineItem {
+    summary?: string;
+    unit: number;
+    unit_price: Money;
+}

package/src/codegen/generated/components/schemas/Money.d.ts

@@ -0,0 +1,11 @@
+import * as t from 'io-ts';
+export declare const Money: t.TypeC<{
+    pence: t.NumberC;
+    currency: t.LiteralC<"GBP">;
+    vat: t.StringC;
+}>;
+export interface Money {
+    pence: number;
+    currency: 'GBP';
+    vat: string;
+}

package/src/codegen/generated/components/schemas/PostPDFInput.d.ts

@@ -0,0 +1,13 @@
+import * as t from 'io-ts';
+import { GenerateType } from './GenerateType';
+export declare const PostPDFInput: t.IntersectionC<[t.TypeC<{
+    generate_type: t.UnionC<[t.LiteralC<"job_quote">, t.LiteralC<"public_liability_insurance">]>;
+    body: t.StringC;
+}>, t.PartialC<{
+    id: t.StringC;
+}>]>;
+export interface PostPDFInput {
+    id?: string;
+    generate_type: GenerateType;
+    body: string;
+}

package/src/codegen/generated/components/schemas/PostPDFOutput.d.ts

@@ -0,0 +1,44 @@
+import * as t from 'io-ts';
+import { JobQuote } from './JobQuote';
+import { PublicLiabilityInsurance } from './PublicLiabilityInsurance';
+export declare const PostPDFOutput: t.UnionC<[t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+    title: t.StringC;
+    items: t.ArrayC<t.IntersectionC<[t.TypeC<{
+        unit: t.NumberC;
+        unit_price: t.TypeC<{
+            pence: t.NumberC;
+            currency: t.LiteralC<"GBP">;
+            vat: t.StringC;
+        }>;
+    }>, t.PartialC<{
+        summary: t.StringC;
+    }>]>>;
+    total_price: t.TypeC<{
+        pence: t.NumberC;
+        currency: t.LiteralC<"GBP">;
+        vat: t.StringC;
+    }>;
+}>, t.PartialC<{
+    description: t.StringC;
+    category: t.StringC;
+    recipient: t.TypeC<{
+        name: t.StringC;
+        email: t.StringC;
+        mobile: t.StringC;
+        address: t.IntersectionC<[t.TypeC<{
+            line_1: t.StringC;
+            city: t.StringC;
+            country: t.StringC;
+        }>, t.PartialC<{
+            line_2: t.StringC;
+            county: t.StringC;
+            postcode: t.StringC;
+        }>]>;
+    }>;
+}>]>, t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+}>, t.PartialC<{
+    expiry: import("io-ts-types").DateFromISOStringC;
+}>]>]>;
+export type PostPDFOutput = JobQuote | PublicLiabilityInsurance;

package/src/codegen/generated/components/schemas/PublicLiabilityInsurance.d.ts

@@ -0,0 +1,10 @@
+import * as t from 'io-ts';
+export declare const PublicLiabilityInsurance: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+}>, t.PartialC<{
+    expiry: import("io-ts-types").DateFromISOStringC;
+}>]>;
+export interface PublicLiabilityInsurance {
+    id: string;
+    expiry?: Date;
+}

package/src/codegen/generated/components/schemas/Recipient.d.ts

@@ -0,0 +1,22 @@
+import * as t from 'io-ts';
+import { Address } from './Address';
+export declare const Recipient: t.TypeC<{
+    name: t.StringC;
+    email: t.StringC;
+    mobile: t.StringC;
+    address: t.IntersectionC<[t.TypeC<{
+        line_1: t.StringC;
+        city: t.StringC;
+        country: t.StringC;
+    }>, t.PartialC<{
+        line_2: t.StringC;
+        county: t.StringC;
+        postcode: t.StringC;
+    }>]>;
+}>;
+export interface Recipient {
+    name: string;
+    email: string;
+    mobile: string;
+    address: Address;
+}

package/src/codegen/generated/components/schemas/User.d.ts

@@ -0,0 +1,33 @@
+import * as t from 'io-ts';
+import { Address } from './Address';
+export declare const User: t.IntersectionC<[t.TypeC<{
+    id: t.StringC;
+    name: t.StringC;
+    email: t.StringC;
+    phone: t.StringC;
+    verified: t.BooleanC;
+    is_admin: t.BooleanC;
+    suspended: t.BooleanC;
+}>, t.PartialC<{
+    address: t.IntersectionC<[t.TypeC<{
+        line_1: t.StringC;
+        city: t.StringC;
+        country: t.StringC;
+    }>, t.PartialC<{
+        line_2: t.StringC;
+        county: t.StringC;
+        postcode: t.StringC;
+    }>]>;
+    token: t.StringC;
+}>]>;
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+    phone: string;
+    address?: Address;
+    token?: string;
+    verified: boolean;
+    is_admin: boolean;
+    suspended: boolean;
+}

package/src/codegen/generated/components/schemas/index.d.ts

@@ -0,0 +1,11 @@
+export * from './User';
+export * from './GenerateType';
+export * from './PostPDFInput';
+export * from './PostPDFOutput';
+export * from './PublicLiabilityInsurance';
+export * from './JobQuote';
+export * from './LineItem';
+export * from './Money';
+export * from './Recipient';
+export * from './Address';
+export * from './Error';

package/src/codegen/generated/operations/getMe.d.ts

@@ -0,0 +1,43 @@
+import type { RequestFunction } from '@openapi-io-ts/runtime';
+import * as schemas from '../components/schemas';
+export declare const getMeOperation: {
+    readonly path: "/api/me";
+    readonly method: "get";
+    readonly responses: {
+        readonly '200': {
+            readonly _tag: "JsonResponse";
+            readonly decoder: import("io-ts").IntersectionC<[import("io-ts").TypeC<{
+                id: import("io-ts").StringC;
+                name: import("io-ts").StringC;
+                email: import("io-ts").StringC;
+                phone: import("io-ts").StringC;
+                verified: import("io-ts").BooleanC;
+                is_admin: import("io-ts").BooleanC;
+                suspended: import("io-ts").BooleanC;
+            }>, import("io-ts").PartialC<{
+                address: import("io-ts").IntersectionC<[import("io-ts").TypeC<{
+                    line_1: import("io-ts").StringC;
+                    city: import("io-ts").StringC;
+                    country: import("io-ts").StringC;
+                }>, import("io-ts").PartialC<{
+                    line_2: import("io-ts").StringC;
+                    county: import("io-ts").StringC;
+                    postcode: import("io-ts").StringC;
+                }>]>;
+                token: import("io-ts").StringC;
+            }>]>;
+        };
+        readonly default: {
+            readonly _tag: "JsonResponse";
+            readonly decoder: import("io-ts").TypeC<{
+                code: import("io-ts").NumberC;
+                message: import("io-ts").StringC;
+            }>;
+        };
+    };
+    readonly parameters: readonly [];
+    readonly requestDefaultHeaders: {
+        readonly Accept: "application/json";
+    };
+};
+export type GetMeRequestFunction = RequestFunction<undefined, schemas.User>;

package/src/codegen/generated/operations/index.d.ts

@@ -0,0 +1,19 @@
+import { HttpRequestAdapter } from '@openapi-io-ts/runtime';
+import { GetMeRequestFunction, getMeOperation } from './getMe';
+import { PostPDFRequestFunction, postPDFOperation } from './postPDF';
+export declare const operations: Operations;
+export interface OperationRequestFunctionMap {
+    getMe: GetMeRequestFunction;
+    postPDF: PostPDFRequestFunction;
+}
+export declare const requestFunctionsBuilder: (requestAdapter: HttpRequestAdapter) => OperationRequestFunctionMap;
+export declare const usersServiceBuilder: (requestFunctions: OperationRequestFunctionMap) => {
+    getMe: GetMeRequestFunction;
+};
+export declare const pdfServiceBuilder: (requestFunctions: OperationRequestFunctionMap) => {
+    postPDF: PostPDFRequestFunction;
+};
+export interface Operations {
+    getMe: typeof getMeOperation;
+    postPDF: typeof postPDFOperation;
+}

package/src/codegen/generated/operations/postPDF.d.ts

@@ -0,0 +1,69 @@
+import type { RequestFunction } from '@openapi-io-ts/runtime';
+import * as schemas from '../components/schemas';
+export declare const postPDFOperation: {
+    readonly path: "/api/pdf";
+    readonly method: "post";
+    readonly responses: {
+        readonly '200': {
+            readonly _tag: "JsonResponse";
+            readonly decoder: import("io-ts").UnionC<[import("io-ts").IntersectionC<[import("io-ts").TypeC<{
+                id: import("io-ts").StringC;
+                title: import("io-ts").StringC;
+                items: import("io-ts").ArrayC<import("io-ts").IntersectionC<[import("io-ts").TypeC<{
+                    unit: import("io-ts").NumberC;
+                    unit_price: import("io-ts").TypeC<{
+                        pence: import("io-ts").NumberC;
+                        currency: import("io-ts").LiteralC<"GBP">;
+                        vat: import("io-ts").StringC;
+                    }>;
+                }>, import("io-ts").PartialC<{
+                    summary: import("io-ts").StringC;
+                }>]>>;
+                total_price: import("io-ts").TypeC<{
+                    pence: import("io-ts").NumberC;
+                    currency: import("io-ts").LiteralC<"GBP">;
+                    vat: import("io-ts").StringC;
+                }>;
+            }>, import("io-ts").PartialC<{
+                description: import("io-ts").StringC;
+                category: import("io-ts").StringC;
+                recipient: import("io-ts").TypeC<{
+                    name: import("io-ts").StringC;
+                    email: import("io-ts").StringC;
+                    mobile: import("io-ts").StringC;
+                    address: import("io-ts").IntersectionC<[import("io-ts").TypeC<{
+                        line_1: import("io-ts").StringC;
+                        city: import("io-ts").StringC;
+                        country: import("io-ts").StringC;
+                    }>, import("io-ts").PartialC<{
+                        line_2: import("io-ts").StringC;
+                        county: import("io-ts").StringC;
+                        postcode: import("io-ts").StringC;
+                    }>]>;
+                }>;
+            }>]>, import("io-ts").IntersectionC<[import("io-ts").TypeC<{
+                id: import("io-ts").StringC;
+            }>, import("io-ts").PartialC<{
+                expiry: import("io-ts-types").DateFromISOStringC;
+            }>]>]>;
+        };
+        readonly default: {
+            readonly _tag: "JsonResponse";
+            readonly decoder: import("io-ts").TypeC<{
+                code: import("io-ts").NumberC;
+                message: import("io-ts").StringC;
+            }>;
+        };
+    };
+    readonly parameters: readonly [];
+    readonly requestDefaultHeaders: {
+        readonly 'Content-Type': "application/json";
+        readonly Accept: "application/json";
+    };
+    readonly body: {
+        readonly _tag: "JsonBody";
+    };
+};
+export type PostPDFRequestFunction = RequestFunction<{
+    body: schemas.PostPDFInput;
+}, schemas.PostPDFOutput>;

package/src/codegen/generated/servers.d.ts

@@ -0,0 +1 @@
+export declare const servers: string[];

package/src/codegen/service/index.d.ts

@@ -0,0 +1,30 @@
+import { KandaAuth, TrackingFunctionsBuilder } from './types';
+import { PostPDFRequestFunction } from '../generated/operations/postPDF';
+import { GetMeRequestFunction } from '../generated/operations/getMe';
+/**
+ * Interfaces for AI service exported
+ */
+export interface AiService<ServiceRequestFunction> {
+    key: string;
+    method: (auth?: KandaAuth, tracking?: TrackingFunctionsBuilder) => ServiceRequestFunction;
+}
+/**
+ * Interfaces for each specifc AI service exported
+ */
+export interface PDFServices {
+    postPDF: AiService<PostPDFRequestFunction>;
+}
+export interface UsersServices {
+    getMe: AiService<GetMeRequestFunction>;
+}
+declare const pdf: PDFServices;
+declare const users: UsersServices;
+/**
+ * A list of all possible services the frontend can use.
+ */
+declare const services: {
+    pdf: PDFServices;
+    users: UsersServices;
+};
+export { pdf, users, };
+export default services;

package/src/codegen/service/types.d.ts

@@ -0,0 +1,19 @@
+import { StringIndexedObject } from '../../types';
+export type KandaAuth = {
+    intercept?: boolean;
+    token?: string;
+    additionalHeaders?: StringIndexedObject;
+    refreshToken?: () => string;
+};
+export interface AuthenticationHeaders {
+    Authorization?: string;
+}
+export interface HttpRequest extends StringIndexedObject {
+    headers: StringIndexedObject & AuthenticationHeaders;
+}
+export interface TrackingFunctions {
+    attempted?: () => void;
+    succeeded?: () => void;
+    failed?: () => void;
+}
+export type TrackingFunctionsBuilder = (url?: string, options?: RequestInit) => TrackingFunctions;

package/src/codegen/service/utils/fetch.d.ts

@@ -0,0 +1,26 @@
+import type { KandaAuth, StringIndexedObject } from '../../../types';
+import { AuthenticationHeaders, HttpRequest, TrackingFunctionsBuilder } from '../types';
+/**
+ * Build the needed authorization headers for API requests
+ * @param token
+ */
+export declare const buildAuth: (token: string) => AuthenticationHeaders;
+/**
+ * Build the needed headers for API requests, including any needed auth
+ * @param init
+ * @param token
+ */
+export declare const cleanHeaders: (headers: StringIndexedObject) => StringIndexedObject;
+/**
+ * Build the needed headers for API requests, including any needed auth
+ * @param init
+ * @param token
+ */
+export declare const buildRequestHeaders: (init: RequestInit, token?: string, additionalHeaders?: StringIndexedObject, ...args: any[]) => HttpRequest;
+export declare const originalFetch: () => any;
+export declare const interceptedFetch: (url: string, options: RequestInit, authOptions?: Omit<KandaAuth, 'intercept'>, trackingFunction?: TrackingFunctionsBuilder, ...args: any[]) => Promise<Response>;
+declare const fetchers: {
+    base: () => any;
+    intercepted: (url: string, options: RequestInit, authOptions?: Omit<KandaAuth, 'intercept'>, trackingFunction?: TrackingFunctionsBuilder, ...args: any[]) => Promise<Response>;
+};
+export default fetchers;

package/src/codegen/service/utils/index.d.ts

@@ -0,0 +1,13 @@
+import * as operations from '../../generated/operations';
+import { KandaAuth, TrackingFunctionsBuilder } from '../types';
+/**
+ * Call fetch, including the baseUrl and attaching headers including authentication
+ * @param baseURL
+ */
+export declare const fetchRequestAdapter: (baseURL: string, auth?: KandaAuth, tracking?: TrackingFunctionsBuilder) => (url: string, init: RequestInit) => Promise<Response>;
+/**
+ * Build request functions for operations using baseUrl
+ * @param baseURL
+ * @param token
+ */
+export declare const requestFunctions: (baseURL: string, auth?: KandaAuth, tracking?: TrackingFunctionsBuilder) => operations.OperationRequestFunctionMap;

package/src/codegen/store/adapters/aiPdfPostPDF.d.ts

@@ -0,0 +1,8 @@
+import { default as aiServices } from '../../service';
+import { RequestFunctionReturnType } from '../types';
+export type AIPdfPostPDFReturn = RequestFunctionReturnType<ReturnType<typeof aiServices.pdf.postPDF.method>>;
+export type AIPdfPostPDFEntity = AIPdfPostPDFReturn[0];
+export type AIPdfPostPDFEntityId = AIPdfPostPDFEntity['id'];
+export type AIPdfPostPDFArgs = AIPdfPostPDFReturn[1];
+declare const aiPdfPostPDFAdapter: import("@reduxjs/toolkit").EntityAdapter<import("index").PostPDFOutput, string>;
+export default aiPdfPostPDFAdapter;

package/src/codegen/store/adapters/aiUsersGetMe.d.ts

@@ -0,0 +1,8 @@
+import { default as aiServices } from '../../service';
+import { RequestFunctionReturnType } from '../types';
+export type AIUsersGetMeReturn = RequestFunctionReturnType<ReturnType<typeof aiServices.users.getMe.method>>;
+export type AIUsersGetMeEntity = AIUsersGetMeReturn[0];
+export type AIUsersGetMeEntityId = AIUsersGetMeEntity['id'];
+export type AIUsersGetMeArgs = AIUsersGetMeReturn[1];
+declare const aiUsersGetMeAdapter: import("@reduxjs/toolkit").EntityAdapter<import("index").User, string>;
+export default aiUsersGetMeAdapter;

package/src/codegen/store/adapters/index.d.ts

@@ -0,0 +1,12 @@
+import { default as aiServices } from '../../service';
+import { RequestFunctionReturnType } from '../types';
+export type AIPdfPostPDFReturn = RequestFunctionReturnType<ReturnType<typeof aiServices.pdf.postPDF.method>>;
+export type AIPdfPostPDFEntity = AIPdfPostPDFReturn[0];
+export type AIPdfPostPDFEntityId = AIPdfPostPDFEntity['id'];
+export type AIPdfPostPDFArgs = AIPdfPostPDFReturn[1];
+export type AIUsersGetMeReturn = RequestFunctionReturnType<ReturnType<typeof aiServices.users.getMe.method>>;
+export type AIUsersGetMeEntity = AIUsersGetMeReturn[0];
+export type AIUsersGetMeEntityId = AIUsersGetMeEntity['id'];
+export type AIUsersGetMeArgs = AIUsersGetMeReturn[1];
+export declare const aiPdfPostPDFAdapter: import("@reduxjs/toolkit").EntityAdapter<import("../../..").PostPDFOutput, string>;
+export declare const aiUsersGetMeAdapter: import("@reduxjs/toolkit").EntityAdapter<import("../../..").User, string>;

package/src/codegen/store/constants.d.ts

@@ -0,0 +1,2 @@
+import { ExtractedError } from './types';
+export declare const UNKNOWN_ERROR: ExtractedError;

package/src/codegen/store/helpers.d.ts

@@ -0,0 +1,24 @@
+import type { ApiError, ApiResponse } from '@openapi-io-ts/runtime';
+import { AsyncThunk, EntityAdapter, EntityId, PayloadAction } from '@reduxjs/toolkit';
+import { Either } from 'fp-ts/lib/Either';
+import { StringIndexedObject } from '../../types';
+import { TrackingFunctionsBuilder } from '../service/types';
+import { AiService, AsyncThunkActionArgs, BaseState, DataWithId, ExtractedError, Selectors } from './types';
+export declare const handleApiResponse: <T>(response: Either<ApiError, ApiResponse<T>>) => Promise<T>;
+export declare const extractError: (error: StringIndexedObject | string | undefined) => ExtractedError;
+export declare const createAsyncThunkAction: <Entity extends void | StringIndexedObject, Args extends StringIndexedObject<any>>(service: AiService<Entity, Args>, trackingFunctionsBuilder?: TrackingFunctionsBuilder) => AsyncThunk<Entity, AsyncThunkActionArgs<Args, Entity>, {
+    rejectValue: ExtractedError;
+}>;
+export declare const createSuccessHandler: <T extends DataWithId, TId extends EntityId>(entityAdapter: EntityAdapter<T, TId>) => (state: BaseState<T, TId>, action: PayloadAction<T>) => BaseState<T, TId>;
+export declare const createArraySuccessHandler: <T extends DataWithId, TId extends EntityId>(entityAdapter: EntityAdapter<T, TId>) => (state: BaseState<T, TId>, action: PayloadAction<T[]>) => BaseState<T, TId>;
+export declare const createVoidSuccessHandler: <T extends DataWithId, TId extends EntityId>(entityAdapter: EntityAdapter<T, TId>) => (state: BaseState<T, TId>) => BaseState<T, TId>;
+export declare const createErrorHandler: <T, TId extends EntityId>() => (state: BaseState<T, TId>, action: PayloadAction<ExtractedError | undefined>) => {
+    error: ExtractedError;
+    isSubmitting: boolean;
+    latestIds?: EntityId[];
+    isLoading: boolean;
+    isValidating: boolean;
+    ids: TId[];
+    entities: Record<TId, T>;
+};
+export declare const generateSelectors: <T, TId extends EntityId, State extends StringIndexedObject<BaseState<T, TId>>>(reducer: keyof State, entityAdapter: EntityAdapter<T, TId>) => Selectors<T, TId, State>;

package/src/codegen/store/index.d.ts

@@ -0,0 +1,7 @@
+export * from './slices';
+export * as aiActions from './slices/generated/actions';
+export * as aiSlices from './slices/generated/';
+export declare const aiSelectors: {
+    aiPdfPostPDF: import("./types").Selectors<import("../..").PostPDFOutput, string, import("../../types").StringIndexedObject<import("./types").BaseState<import("../..").PostPDFOutput, string>>>;
+    aiUsersGetMe: import("./types").Selectors<import("../..").User, string, import("../../types").StringIndexedObject<import("./types").BaseState<import("../..").User, string>>>;
+};

package/src/codegen/store/selectors/index.d.ts

@@ -0,0 +1,6 @@
+import { StringIndexedObject } from '../../../types';
+import { BaseState } from '../types';
+export declare const getSelectors: () => {
+    aiPdfPostPDF: import("../types").Selectors<import("../../..").PostPDFOutput, string, StringIndexedObject<BaseState<import("../../..").PostPDFOutput, string>>>;
+    aiUsersGetMe: import("../types").Selectors<import("../../..").User, string, StringIndexedObject<BaseState<import("../../..").User, string>>>;
+};

package/src/codegen/store/slices/actions.d.ts

@@ -0,0 +1 @@
+export declare const reset: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"RESET">;

package/src/codegen/store/slices/generated/actions.d.ts

@@ -0,0 +1,2 @@
+export { aiPdfPostPDF } from './aiPdfPostPDF';
+export { aiUsersGetMe } from './aiUsersGetMe';

package/src/codegen/store/slices/generated/aiPdfPostPDF.d.ts

@@ -0,0 +1,17 @@
+import { AIPdfPostPDFEntity, AIPdfPostPDFEntityId } from '../../adapters';
+import { AsyncThunkReturnType, BaseState } from '../../types';
+export declare const aiPdfPostPDF: import("@reduxjs/toolkit").AsyncThunk<import("../../../..").PostPDFOutput, {
+    body: import("../../../..").PostPDFInput;
+} & import("../../types").SharedAsyncThunkActionArgs<import("../../../..").PostPDFOutput>, {
+    rejectValue: import("../../types").ExtractedError;
+}>;
+export type AIPdfPostPDFThunkReturn = AsyncThunkReturnType<typeof aiPdfPostPDF>;
+export type AIPdfPostPDFThunkArgs = AIPdfPostPDFThunkReturn[1];
+export type AIPdfPostPDFConfig = AIPdfPostPDFThunkReturn[2];
+export type AIPdfPostPDFState = BaseState<AIPdfPostPDFEntity, AIPdfPostPDFEntityId>;
+export declare const aiPdfPostPDFInitialState: AIPdfPostPDFState;
+export declare const aiPdfPostPDFSlice: import("@reduxjs/toolkit").Slice<AIPdfPostPDFState, {
+    resetService: () => AIPdfPostPDFState;
+}, "ai.pdf.postPDF", "ai.pdf.postPDF", import("@reduxjs/toolkit").SliceSelectors<AIPdfPostPDFState>>;
+declare const _default: import("@reduxjs/toolkit").Reducer<AIPdfPostPDFState>;
+export default _default;