feat: projects create, update, delete

package.json

@@ -7,7 +7,7 @@
     "build": "next build",
     "start": "next start",
     "lint": "next lint",
-    "generate-client": "openapi-ts && prettier --write ./src/client/**/*.ts && git add ./src/client"
+    "generate-client": "openapi-ts && prettier --write ./src/lib/client/**/*.ts && git add ./src/lib/client"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",

src/app/deals/components/shared/Header/Header.tsx

@@ -11,8 +11,12 @@ import { ColorSchemeToggle } from "@/components/ui/ColorSchemeToggle/ColorScheme
 import useIsMobile from "@/hooks/useIsMobile";
 
 const Header = () => {
-    const { projects, setSelectedProject, selectedProject } =
+    const {
-        useProjectsContext();
+        projects,
+        setSelectedProject,
+        selectedProject,
+        setIsEditorDrawerOpened: setIsProjectsDrawerOpened,
+    } = useProjectsContext();
     const { setIsEditorDrawerOpened } = useBoardsContext();
     const isMobile = useIsMobile();
 
@@ -38,7 +42,9 @@ const Header = () => {
         return (
             <Stack gap={0}>
                 <Group justify={"space-between"}>
-                    <Box p={"md"}>
+                    <Box
+                        p={"md"}
+                        onClick={() => setIsProjectsDrawerOpened(true)}>
                         <IconChevronLeft />
                     </Box>
                     <Text>{selectedProject?.name}</Text>

src/app/deals/contexts/ProjectsContext.tsx

@@ -7,8 +7,9 @@ import React, {
     useEffect,
     useState,
 } from "react";
-import { ProjectSchema } from "@/lib/client";
 import useProjectsList from "@/hooks/useProjectsList";
+import { useProjectsOperations } from "@/hooks/useProjectsOperations";
+import { ProjectSchema, UpdateProjectSchema } from "@/lib/client";
 
 type ProjectsContextState = {
     selectedProject: ProjectSchema | null;
@@ -16,6 +17,11 @@ type ProjectsContextState = {
         React.SetStateAction<ProjectSchema | null>
     >;
     projects: ProjectSchema[];
+    onCreateProject: (name: string) => void;
+    onUpdateProject: (projectId: number, project: UpdateProjectSchema) => void;
+    onDeleteProject: (project: ProjectSchema) => void;
+    isEditorDrawerOpened: boolean;
+    setIsEditorDrawerOpened: React.Dispatch<React.SetStateAction<boolean>>;
 };
 
 const ProjectsContext = createContext<ProjectsContextState | undefined>(
@@ -23,7 +29,13 @@ const ProjectsContext = createContext<ProjectsContextState | undefined>(
 );
 
 const useProjectsContextState = () => {
-    const { projects } = useProjectsList();
+    const [isEditorDrawerOpened, setIsEditorDrawerOpened] =
+        useState<boolean>(false);
+    const {
+        projects,
+        setProjects,
+        refetch: refetchProjects,
+    } = useProjectsList();
     const [selectedProject, setSelectedProject] =
         useState<ProjectSchema | null>(null);
 
@@ -43,10 +55,22 @@ const useProjectsContextState = () => {
         setSelectedProject(null);
     }, [projects]);
 
+    const { onCreateProject, onUpdateProject, onDeleteProject } =
+        useProjectsOperations({
+            projects,
+            setProjects,
+            refetchProjects,
+        });
+
     return {
         projects,
         selectedProject,
         setSelectedProject,
+        onCreateProject,
+        onUpdateProject,
+        onDeleteProject,
+        isEditorDrawerOpened,
+        setIsEditorDrawerOpened,
     };
 };
 

src/app/deals/drawers/ProjectsEditorDrawer/ProjectsEditorDrawer.module.css

@@ -0,0 +1,15 @@
+.project:hover {
+    background-color: whitesmoke;
+
+    @mixin dark {
+        background-color: var(--mantine-color-dark-6);
+    }
+}
+
+.menu-button {
+    cursor: pointer;
+}
+
+.project:hover:has(.menu-button:hover) {
+    background: none; /* or revert to normal */
+}

src/app/deals/drawers/ProjectsEditorDrawer/ProjectsEditorDrawer.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import React, { FC } from "react";
+import { IconChevronLeft } from "@tabler/icons-react";
+import {
+    Box,
+    Center,
+    Divider,
+    Drawer,
+    Group,
+    rem,
+    Stack,
+    Text,
+} from "@mantine/core";
+import { useProjectsContext } from "@/app/deals/contexts/ProjectsContext";
+import CreateProjectButton from "@/app/deals/drawers/ProjectsEditorDrawer/components/CreateProjectButton";
+import ProjectMobile from "@/app/deals/drawers/ProjectsEditorDrawer/components/ProjectMobile";
+
+const ProjectsEditorDrawer: FC = () => {
+    const { projects, isEditorDrawerOpened, setIsEditorDrawerOpened } =
+        useProjectsContext();
+    const onClose = () => setIsEditorDrawerOpened(false);
+
+    return (
+        <Drawer
+            size={"100%"}
+            position={"left"}
+            onClose={onClose}
+            removeScrollProps={{ allowPinchZoom: true }}
+            withCloseButton={false}
+            opened={isEditorDrawerOpened}
+            trapFocus={false}
+            styles={{
+                body: {
+                    height: "100%",
+                    display: "flex",
+                    flexDirection: "column",
+                    gap: rem(10),
+                },
+            }}>
+            <Group justify={"space-between"}>
+                <Box
+                    onClick={onClose}
+                    p={"xs"}>
+                    <IconChevronLeft />
+                </Box>
+                <Center>
+                    <Text>Проекты</Text>
+                </Center>
+                <Box p={"lg"} />
+            </Group>
+            <Divider />
+            <Stack gap={0}>
+                {projects.map((project, index) => (
+                    <ProjectMobile
+                        key={index}
+                        project={project}
+                    />
+                ))}
+            </Stack>
+            <CreateProjectButton />
+        </Drawer>
+    );
+};
+
+export default ProjectsEditorDrawer;

src/app/deals/drawers/ProjectsEditorDrawer/components/CreateProjectButton.tsx

@@ -0,0 +1,32 @@
+import { IconPlus } from "@tabler/icons-react";
+import { Box, Group, Text } from "@mantine/core";
+import { modals } from "@mantine/modals";
+import { useProjectsContext } from "@/app/deals/contexts/ProjectsContext";
+
+const CreateProjectButton = () => {
+    const { onCreateProject } = useProjectsContext();
+
+    const onStartCreating = () => {
+        modals.openContextModal({
+            modal: "enterNameModal",
+            title: "Создание проекта",
+            withCloseButton: true,
+            innerProps: {
+                onComplete: onCreateProject,
+            },
+        });
+    };
+
+    return (
+        <Group
+            ml={"xs"}
+            onClick={onStartCreating}>
+            <IconPlus />
+            <Box mt={5}>
+                <Text>Создать проект</Text>
+            </Box>
+        </Group>
+    );
+};
+
+export default CreateProjectButton;

src/app/deals/drawers/ProjectsEditorDrawer/components/ProjectMenu.tsx

@@ -0,0 +1,56 @@
+import React, { FC } from "react";
+import { IconDotsVertical, IconEdit, IconTrash } from "@tabler/icons-react";
+import { Box, Group, Menu, Text } from "@mantine/core";
+import { useProjectsContext } from "@/app/deals/contexts/ProjectsContext";
+import { ProjectSchema } from "@/lib/client";
+import styles from "./../ProjectsEditorDrawer.module.css";
+
+type Props = {
+    project: ProjectSchema;
+    startEditing: () => void;
+    menuIconSize: number;
+};
+
+const ProjectMenu: FC<Props> = ({
+    project,
+    startEditing,
+    menuIconSize = 16,
+}) => {
+    const { onDeleteProject } = useProjectsContext();
+
+    return (
+        <Menu>
+            <Menu.Target>
+                <Box
+                    className={styles["menu-button"]}
+                    onClick={e => e.stopPropagation()}>
+                    <IconDotsVertical size={menuIconSize} />
+                </Box>
+            </Menu.Target>
+            <Menu.Dropdown>
+                <Menu.Item
+                    onClick={e => {
+                        e.stopPropagation();
+                        startEditing();
+                    }}>
+                    <Group wrap={"nowrap"}>
+                        <IconEdit />
+                        <Text>Переименовать</Text>
+                    </Group>
+                </Menu.Item>
+                <Menu.Item
+                    onClick={e => {
+                        e.stopPropagation();
+                        onDeleteProject(project);
+                    }}>
+                    <Group wrap={"nowrap"}>
+                        <IconTrash />
+                        <Text>Удалить</Text>
+                    </Group>
+                </Menu.Item>
+            </Menu.Dropdown>
+        </Menu>
+    );
+};
+
+export default ProjectMenu;

src/app/deals/drawers/ProjectsEditorDrawer/components/ProjectMobile.tsx

@@ -0,0 +1,55 @@
+import React, { FC } from "react";
+import { Box, Group, Text } from "@mantine/core";
+import { modals } from "@mantine/modals";
+import { useProjectsContext } from "@/app/deals/contexts/ProjectsContext";
+import ProjectMenu from "@/app/deals/drawers/ProjectsEditorDrawer/components/ProjectMenu";
+import { ProjectSchema } from "@/lib/client";
+import styles from "./../ProjectsEditorDrawer.module.css";
+
+type Props = {
+    project: ProjectSchema;
+};
+
+const ProjectMobile: FC<Props> = ({ project }) => {
+    const { onUpdateProject, setSelectedProject, setIsEditorDrawerOpened } =
+        useProjectsContext();
+
+    const startEditing = () => {
+        modals.openContextModal({
+            modal: "enterNameModal",
+            title: "Редактирование проекта",
+            withCloseButton: true,
+            innerProps: {
+                onComplete: name => onUpdateProject(project.id, { name }),
+                defaultValue: project.name,
+            },
+        });
+    };
+
+    const onClick = () => {
+        setSelectedProject(project);
+        setIsEditorDrawerOpened(false);
+    };
+
+    return (
+        <Group
+            w={"100%"}
+            pl={"xs"}
+            py={"xs"}
+            justify={"space-between"}
+            wrap={"nowrap"}
+            className={styles.project}
+            onClick={onClick}>
+            <Box>
+                <Text>{project.name}</Text>
+            </Box>
+            <ProjectMenu
+                project={project}
+                startEditing={startEditing}
+                menuIconSize={22}
+            />
+        </Group>
+    );
+};
+
+export default ProjectMobile;

src/app/deals/drawers/ProjectsEditorDrawer/index.ts

@@ -0,0 +1,3 @@
+import ProjectsEditorDrawer from "@/app/deals/drawers/ProjectsEditorDrawer/ProjectsEditorDrawer";
+
+export default ProjectsEditorDrawer;

src/app/deals/page.tsx

@@ -5,6 +5,7 @@ import { ProjectsContextProvider } from "@/app/deals/contexts/ProjectsContext";
 import { StatusesContextProvider } from "@/app/deals/contexts/StatusesContext";
 import BoardStatusesEditorDrawer from "@/app/deals/drawers/BoardStatusesEditorDrawer";
 import ProjectBoardsEditorDrawer from "@/app/deals/drawers/ProjectBoardsEditorDrawer";
+import ProjectsEditorDrawer from "@/app/deals/drawers/ProjectsEditorDrawer";
 import PageBlock from "@/components/layout/PageBlock/PageBlock";
 import PageContainer from "@/components/layout/PageContainer/PageContainer";
 import { DealsContextProvider } from "./contexts/DealsContext";
@@ -27,6 +28,7 @@ export default function DealsPage() {
                             <BoardStatusesEditorDrawer />
                         </StatusesContextProvider>
                         <ProjectBoardsEditorDrawer />
+                        <ProjectsEditorDrawer />
                     </PageBlock>
                 </PageContainer>
             </BoardsContextProvider>

src/hooks/useProjectsList.ts

@@ -1,12 +1,22 @@
+import { useEffect, useState } from "react";
 import { useQuery } from "@tanstack/react-query";
+import { ProjectSchema } from "@/lib/client";
 import { getProjectsOptions } from "@/lib/client/@tanstack/react-query.gen";
 
 const useProjectsList = () => {
+    const [projects, setProjects] = useState<ProjectSchema[]>([]);
+
     const { data, refetch, isLoading } = useQuery({
         ...getProjectsOptions(),
     });
-    const projects = !data ? [] : data.projects;
+
-    return { projects, refetch, isLoading };
+    useEffect(() => {
+        if (data?.projects) {
+            setProjects(data.projects);
+        }
+    }, [data?.projects]);
+
+    return { projects, setProjects, refetch, isLoading };
 };
 
 export default useProjectsList;

src/hooks/useProjectsOperations.tsx

@@ -0,0 +1,112 @@
+import React from "react";
+import { useMutation } from "@tanstack/react-query";
+import { AxiosError } from "axios";
+import { Text } from "@mantine/core";
+import { modals } from "@mantine/modals";
+import {
+    HttpValidationError,
+    ProjectSchema,
+    UpdateProjectSchema,
+} from "@/lib/client";
+import {
+    createProjectMutation,
+    deleteProjectMutation,
+    updateProjectMutation,
+} from "@/lib/client/@tanstack/react-query.gen";
+import { notifications } from "@/lib/notifications";
+
+type Props = {
+    projects: ProjectSchema[];
+    setProjects: React.Dispatch<React.SetStateAction<ProjectSchema[]>>;
+    refetchProjects: () => void;
+};
+
+export const useProjectsOperations = ({
+    projects,
+    setProjects,
+    refetchProjects,
+}: Props) => {
+    const onError = (error: AxiosError<HttpValidationError>) => {
+        console.error(error);
+        notifications.error({
+            message: error.response?.data?.detail as string | undefined,
+        });
+        refetchProjects();
+    };
+
+    const createProject = useMutation({
+        ...createProjectMutation(),
+        onError,
+        onSuccess: res => {
+            setProjects([...projects, res.project]);
+        },
+    });
+
+    const updateProject = useMutation({
+        ...updateProjectMutation(),
+        onError,
+    });
+
+    const deleteProject = useMutation({
+        ...deleteProjectMutation(),
+        onError,
+    });
+
+    const onCreateProject = (name: string) => {
+        createProject.mutate({
+            body: {
+                project: {
+                    name,
+                },
+            },
+        });
+    };
+
+    const onUpdateProject = (
+        projectId: number,
+        project: UpdateProjectSchema
+    ) => {
+        updateProject.mutate({
+            query: { projectId },
+            body: { project },
+        });
+
+        setProjects(boards =>
+            boards.map(oldProject =>
+                oldProject.id !== projectId
+                    ? oldProject
+                    : {
+                          id: oldProject.id,
+                          name: project.name ? project.name : oldProject.name,
+                      }
+            )
+        );
+    };
+
+    const onDeleteProject = (project: ProjectSchema) => {
+        modals.openConfirmModal({
+            title: "Удаление проекта",
+            children: (
+                <Text>
+                    Вы уверены, что хотите удалить проект "{project.name}"?
+                </Text>
+            ),
+            labels: { confirm: "Да", cancel: "Нет" },
+            confirmProps: { color: "red" },
+            onConfirm: () => {
+                deleteProject.mutate({
+                    query: { projectId: project.id },
+                });
+                setProjects(projects =>
+                    projects.filter(p => p.id !== project.id)
+                );
+            },
+        });
+    };
+
+    return {
+        onCreateProject,
+        onUpdateProject,
+        onDeleteProject,
+    };
+};

src/lib/client/@tanstack/react-query.gen.ts

@@ -1,22 +1,80 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
-import { type Options, getBoards, createBoard, deleteBoard, updateBoard, getDeals, updateDeal, getProjects, getStatuses, createStatus, deleteStatus, updateStatus } from '../sdk.gen';
+import { queryOptions, type UseMutationOptions } from "@tanstack/react-query";
-import { queryOptions, type UseMutationOptions } from '@tanstack/react-query';
+import type { AxiosError } from "axios";
-import type { GetBoardsData, CreateBoardData, CreateBoardError, CreateBoardResponse2, DeleteBoardData, DeleteBoardError, DeleteBoardResponse2, UpdateBoardData, UpdateBoardError, UpdateBoardResponse2, GetDealsData, UpdateDealData, UpdateDealError, UpdateDealResponse2, GetProjectsData, GetStatusesData, CreateStatusData, CreateStatusError, CreateStatusResponse2, DeleteStatusData, DeleteStatusError, DeleteStatusResponse2, UpdateStatusData, UpdateStatusError, UpdateStatusResponse2 } from '../types.gen';
+import { client as _heyApiClient } from "../client.gen";
-import type { AxiosError } from 'axios';
+import {
-import { client as _heyApiClient } from '../client.gen';
+    createBoard,
+    createProject,
+    createStatus,
+    deleteBoard,
+    deleteProject,
+    deleteStatus,
+    getBoards,
+    getDeals,
+    getProjects,
+    getStatuses,
+    updateBoard,
+    updateDeal,
+    updateProject,
+    updateStatus,
+    type Options,
+} from "../sdk.gen";
+import type {
+    CreateBoardData,
+    CreateBoardError,
+    CreateBoardResponse2,
+    CreateProjectData,
+    CreateProjectError,
+    CreateProjectResponse2,
+    CreateStatusData,
+    CreateStatusError,
+    CreateStatusResponse2,
+    DeleteBoardData,
+    DeleteBoardError,
+    DeleteBoardResponse2,
+    DeleteProjectData,
+    DeleteProjectError,
+    DeleteProjectResponse2,
+    DeleteStatusData,
+    DeleteStatusError,
+    DeleteStatusResponse2,
+    GetBoardsData,
+    GetDealsData,
+    GetProjectsData,
+    GetStatusesData,
+    UpdateBoardData,
+    UpdateBoardError,
+    UpdateBoardResponse2,
+    UpdateDealData,
+    UpdateDealError,
+    UpdateDealResponse2,
+    UpdateProjectData,
+    UpdateProjectError,
+    UpdateProjectResponse2,
+    UpdateStatusData,
+    UpdateStatusError,
+    UpdateStatusResponse2,
+} from "../types.gen";
 
 export type QueryKey<TOptions extends Options> = [
-    Pick<TOptions, 'baseURL' | 'body' | 'headers' | 'path' | 'query'> & {
+    Pick<TOptions, "baseURL" | "body" | "headers" | "path" | "query"> & {
         _id: string;
         _infinite?: boolean;
-    }
+    },
 ];
 
-const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions, infinite?: boolean): [
+const createQueryKey = <TOptions extends Options>(
-    QueryKey<TOptions>[0]
+    id: string,
-] => {
+    options?: TOptions,
-    const params: QueryKey<TOptions>[0] = { _id: id, baseURL: options?.baseURL || (options?.client ?? _heyApiClient).getConfig().baseURL } as QueryKey<TOptions>[0];
+    infinite?: boolean
+): [QueryKey<TOptions>[0]] => {
+    const params: QueryKey<TOptions>[0] = {
+        _id: id,
+        baseURL:
+            options?.baseURL ||
+            (options?.client ?? _heyApiClient).getConfig().baseURL,
+    } as QueryKey<TOptions>[0];
     if (infinite) {
         params._infinite = infinite;
     }
@@ -32,12 +90,11 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
     if (options?.query) {
         params.query = options.query;
     }
-    return [
+    return [params];
-        params
-    ];
 };
 
-export const getBoardsQueryKey = (options: Options<GetBoardsData>) => createQueryKey('getBoards', options);
+export const getBoardsQueryKey = (options: Options<GetBoardsData>) =>
+    createQueryKey("getBoards", options);
 
 /**
  * Get Boards
@@ -49,15 +106,16 @@ export const getBoardsOptions = (options: Options<GetBoardsData>) => {
                 ...options,
                 ...queryKey[0],
                 signal,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
         },
-        queryKey: getBoardsQueryKey(options)
+        queryKey: getBoardsQueryKey(options),
     });
 };
 
-export const createBoardQueryKey = (options: Options<CreateBoardData>) => createQueryKey('createBoard', options);
+export const createBoardQueryKey = (options: Options<CreateBoardData>) =>
+    createQueryKey("createBoard", options);
 
 /**
  * Create Board
@@ -69,27 +127,37 @@ export const createBoardOptions = (options: Options<CreateBoardData>) => {
                 ...options,
                 ...queryKey[0],
                 signal,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
         },
-        queryKey: createBoardQueryKey(options)
+        queryKey: createBoardQueryKey(options),
     });
 };
 
 /**
  * Create Board
  */
-export const createBoardMutation = (options?: Partial<Options<CreateBoardData>>): UseMutationOptions<CreateBoardResponse2, AxiosError<CreateBoardError>, Options<CreateBoardData>> => {
+export const createBoardMutation = (
-    const mutationOptions: UseMutationOptions<CreateBoardResponse2, AxiosError<CreateBoardError>, Options<CreateBoardData>> = {
+    options?: Partial<Options<CreateBoardData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    CreateBoardResponse2,
+    AxiosError<CreateBoardError>,
+    Options<CreateBoardData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        CreateBoardResponse2,
+        AxiosError<CreateBoardError>,
+        Options<CreateBoardData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await createBoard({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };
@@ -97,16 +165,26 @@ export const createBoardMutation = (options?: Partial<Options<CreateBoardData>>)
 /**
  * Delete Board
  */
-export const deleteBoardMutation = (options?: Partial<Options<DeleteBoardData>>): UseMutationOptions<DeleteBoardResponse2, AxiosError<DeleteBoardError>, Options<DeleteBoardData>> => {
+export const deleteBoardMutation = (
-    const mutationOptions: UseMutationOptions<DeleteBoardResponse2, AxiosError<DeleteBoardError>, Options<DeleteBoardData>> = {
+    options?: Partial<Options<DeleteBoardData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    DeleteBoardResponse2,
+    AxiosError<DeleteBoardError>,
+    Options<DeleteBoardData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        DeleteBoardResponse2,
+        AxiosError<DeleteBoardError>,
+        Options<DeleteBoardData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await deleteBoard({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };
@@ -114,21 +192,32 @@ export const deleteBoardMutation = (options?: Partial<Options<DeleteBoardData>>)
 /**
  * Update Board
  */
-export const updateBoardMutation = (options?: Partial<Options<UpdateBoardData>>): UseMutationOptions<UpdateBoardResponse2, AxiosError<UpdateBoardError>, Options<UpdateBoardData>> => {
+export const updateBoardMutation = (
-    const mutationOptions: UseMutationOptions<UpdateBoardResponse2, AxiosError<UpdateBoardError>, Options<UpdateBoardData>> = {
+    options?: Partial<Options<UpdateBoardData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    UpdateBoardResponse2,
+    AxiosError<UpdateBoardError>,
+    Options<UpdateBoardData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        UpdateBoardResponse2,
+        AxiosError<UpdateBoardError>,
+        Options<UpdateBoardData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await updateBoard({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };
 
-export const getDealsQueryKey = (options: Options<GetDealsData>) => createQueryKey('getDeals', options);
+export const getDealsQueryKey = (options: Options<GetDealsData>) =>
+    createQueryKey("getDeals", options);
 
 /**
  * Get Deals
@@ -140,32 +229,43 @@ export const getDealsOptions = (options: Options<GetDealsData>) => {
                 ...options,
                 ...queryKey[0],
                 signal,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
         },
-        queryKey: getDealsQueryKey(options)
+        queryKey: getDealsQueryKey(options),
     });
 };
 
 /**
  * Update Deal
  */
-export const updateDealMutation = (options?: Partial<Options<UpdateDealData>>): UseMutationOptions<UpdateDealResponse2, AxiosError<UpdateDealError>, Options<UpdateDealData>> => {
+export const updateDealMutation = (
-    const mutationOptions: UseMutationOptions<UpdateDealResponse2, AxiosError<UpdateDealError>, Options<UpdateDealData>> = {
+    options?: Partial<Options<UpdateDealData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    UpdateDealResponse2,
+    AxiosError<UpdateDealError>,
+    Options<UpdateDealData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        UpdateDealResponse2,
+        AxiosError<UpdateDealError>,
+        Options<UpdateDealData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await updateDeal({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };
 
-export const getProjectsQueryKey = (options?: Options<GetProjectsData>) => createQueryKey('getProjects', options);
+export const getProjectsQueryKey = (options?: Options<GetProjectsData>) =>
+    createQueryKey("getProjects", options);
 
 /**
  * Get Projects
@@ -177,15 +277,118 @@ export const getProjectsOptions = (options?: Options<GetProjectsData>) => {
                 ...options,
                 ...queryKey[0],
                 signal,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
         },
-        queryKey: getProjectsQueryKey(options)
+        queryKey: getProjectsQueryKey(options),
     });
 };
 
-export const getStatusesQueryKey = (options: Options<GetStatusesData>) => createQueryKey('getStatuses', options);
+export const createProjectQueryKey = (options: Options<CreateProjectData>) =>
+    createQueryKey("createProject", options);
+
+/**
+ * Create Project
+ */
+export const createProjectOptions = (options: Options<CreateProjectData>) => {
+    return queryOptions({
+        queryFn: async ({ queryKey, signal }) => {
+            const { data } = await createProject({
+                ...options,
+                ...queryKey[0],
+                signal,
+                throwOnError: true,
+            });
+            return data;
+        },
+        queryKey: createProjectQueryKey(options),
+    });
+};
+
+/**
+ * Create Project
+ */
+export const createProjectMutation = (
+    options?: Partial<Options<CreateProjectData>>
+): UseMutationOptions<
+    CreateProjectResponse2,
+    AxiosError<CreateProjectError>,
+    Options<CreateProjectData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        CreateProjectResponse2,
+        AxiosError<CreateProjectError>,
+        Options<CreateProjectData>
+    > = {
+        mutationFn: async localOptions => {
+            const { data } = await createProject({
+                ...options,
+                ...localOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+
+/**
+ * Delete Project
+ */
+export const deleteProjectMutation = (
+    options?: Partial<Options<DeleteProjectData>>
+): UseMutationOptions<
+    DeleteProjectResponse2,
+    AxiosError<DeleteProjectError>,
+    Options<DeleteProjectData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        DeleteProjectResponse2,
+        AxiosError<DeleteProjectError>,
+        Options<DeleteProjectData>
+    > = {
+        mutationFn: async localOptions => {
+            const { data } = await deleteProject({
+                ...options,
+                ...localOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+
+/**
+ * Update Project
+ */
+export const updateProjectMutation = (
+    options?: Partial<Options<UpdateProjectData>>
+): UseMutationOptions<
+    UpdateProjectResponse2,
+    AxiosError<UpdateProjectError>,
+    Options<UpdateProjectData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        UpdateProjectResponse2,
+        AxiosError<UpdateProjectError>,
+        Options<UpdateProjectData>
+    > = {
+        mutationFn: async localOptions => {
+            const { data } = await updateProject({
+                ...options,
+                ...localOptions,
+                throwOnError: true,
+            });
+            return data;
+        },
+    };
+    return mutationOptions;
+};
+
+export const getStatusesQueryKey = (options: Options<GetStatusesData>) =>
+    createQueryKey("getStatuses", options);
 
 /**
  * Get Statuses
@@ -197,15 +400,16 @@ export const getStatusesOptions = (options: Options<GetStatusesData>) => {
                 ...options,
                 ...queryKey[0],
                 signal,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
         },
-        queryKey: getStatusesQueryKey(options)
+        queryKey: getStatusesQueryKey(options),
     });
 };
 
-export const createStatusQueryKey = (options: Options<CreateStatusData>) => createQueryKey('createStatus', options);
+export const createStatusQueryKey = (options: Options<CreateStatusData>) =>
+    createQueryKey("createStatus", options);
 
 /**
  * Create Status
@@ -217,27 +421,37 @@ export const createStatusOptions = (options: Options<CreateStatusData>) => {
                 ...options,
                 ...queryKey[0],
                 signal,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
         },
-        queryKey: createStatusQueryKey(options)
+        queryKey: createStatusQueryKey(options),
     });
 };
 
 /**
  * Create Status
  */
-export const createStatusMutation = (options?: Partial<Options<CreateStatusData>>): UseMutationOptions<CreateStatusResponse2, AxiosError<CreateStatusError>, Options<CreateStatusData>> => {
+export const createStatusMutation = (
-    const mutationOptions: UseMutationOptions<CreateStatusResponse2, AxiosError<CreateStatusError>, Options<CreateStatusData>> = {
+    options?: Partial<Options<CreateStatusData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    CreateStatusResponse2,
+    AxiosError<CreateStatusError>,
+    Options<CreateStatusData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        CreateStatusResponse2,
+        AxiosError<CreateStatusError>,
+        Options<CreateStatusData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await createStatus({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };
@@ -245,16 +459,26 @@ export const createStatusMutation = (options?: Partial<Options<CreateStatusData>
 /**
  * Delete Status
  */
-export const deleteStatusMutation = (options?: Partial<Options<DeleteStatusData>>): UseMutationOptions<DeleteStatusResponse2, AxiosError<DeleteStatusError>, Options<DeleteStatusData>> => {
+export const deleteStatusMutation = (
-    const mutationOptions: UseMutationOptions<DeleteStatusResponse2, AxiosError<DeleteStatusError>, Options<DeleteStatusData>> = {
+    options?: Partial<Options<DeleteStatusData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    DeleteStatusResponse2,
+    AxiosError<DeleteStatusError>,
+    Options<DeleteStatusData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        DeleteStatusResponse2,
+        AxiosError<DeleteStatusError>,
+        Options<DeleteStatusData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await deleteStatus({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };
@@ -262,16 +486,26 @@ export const deleteStatusMutation = (options?: Partial<Options<DeleteStatusData>
 /**
  * Update Status
  */
-export const updateStatusMutation = (options?: Partial<Options<UpdateStatusData>>): UseMutationOptions<UpdateStatusResponse2, AxiosError<UpdateStatusError>, Options<UpdateStatusData>> => {
+export const updateStatusMutation = (
-    const mutationOptions: UseMutationOptions<UpdateStatusResponse2, AxiosError<UpdateStatusError>, Options<UpdateStatusData>> = {
+    options?: Partial<Options<UpdateStatusData>>
-        mutationFn: async (localOptions) => {
+): UseMutationOptions<
+    UpdateStatusResponse2,
+    AxiosError<UpdateStatusError>,
+    Options<UpdateStatusData>
+> => {
+    const mutationOptions: UseMutationOptions<
+        UpdateStatusResponse2,
+        AxiosError<UpdateStatusError>,
+        Options<UpdateStatusData>
+    > = {
+        mutationFn: async localOptions => {
             const { data } = await updateStatus({
                 ...options,
                 ...localOptions,
-                throwOnError: true
+                throwOnError: true,
             });
             return data;
-        }
+        },
     };
     return mutationOptions;
 };

src/lib/client/client.gen.ts

@@ -1,8 +1,13 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
-import type { ClientOptions } from './types.gen';
+import { createClientConfig } from "../../hey-api-config";
-import { type Config, type ClientOptions as DefaultClientOptions, createClient, createConfig } from './client';
+import {
-import { createClientConfig } from '../../hey-api-config';
+    createClient,
+    createConfig,
+    type Config,
+    type ClientOptions as DefaultClientOptions,
+} from "./client";
+import type { ClientOptions } from "./types.gen";
 
 /**
  * The `createClientConfig()` function will be called on client initialization
@@ -12,8 +17,15 @@ import { createClientConfig } from '../../hey-api-config';
  * `setConfig()`. This is useful for example if you're using Next.js
  * to ensure your client always has the correct values.
  */
-export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> = (override?: Config<DefaultClientOptions & T>) => Config<Required<DefaultClientOptions> & T>;
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> =
+    (
+        override?: Config<DefaultClientOptions & T>
+    ) => Config<Required<DefaultClientOptions> & T>;
 
-export const client = createClient(createClientConfig(createConfig<ClientOptions>({
+export const client = createClient(
-    baseURL: '/api'
+    createClientConfig(
-})));
+        createConfig<ClientOptions>({
+            baseURL: "/api",
+        })
+    )
+);

src/lib/client/client/client.ts

@@ -1,115 +1,114 @@
-import type { AxiosError, RawAxiosRequestHeaders } from 'axios';
+import type { AxiosError, RawAxiosRequestHeaders } from "axios";
-import axios from 'axios';
+import axios from "axios";
-
+import type { Client, Config } from "./types";
-import type { Client, Config } from './types';
 import {
-  buildUrl,
+    buildUrl,
-  createConfig,
+    createConfig,
-  mergeConfigs,
+    mergeConfigs,
-  mergeHeaders,
+    mergeHeaders,
-  setAuthParams,
+    setAuthParams,
-} from './utils';
+} from "./utils";
 
 export const createClient = (config: Config = {}): Client => {
-  let _config = mergeConfigs(createConfig(), config);
+    let _config = mergeConfigs(createConfig(), config);
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { auth, ...configWithoutAuth } = _config;
+    const { auth, ...configWithoutAuth } = _config;
-  const instance = axios.create(configWithoutAuth);
+    const instance = axios.create(configWithoutAuth);
 
-  const getConfig = (): Config => ({ ..._config });
+    const getConfig = (): Config => ({ ..._config });
 
-  const setConfig = (config: Config): Config => {
+    const setConfig = (config: Config): Config => {
-    _config = mergeConfigs(_config, config);
+        _config = mergeConfigs(_config, config);
-    instance.defaults = {
+        instance.defaults = {
-      ...instance.defaults,
+            ...instance.defaults,
-      ..._config,
+            ..._config,
-      // @ts-expect-error
+            // @ts-expect-error
-      headers: mergeHeaders(instance.defaults.headers, _config.headers),
+            headers: mergeHeaders(instance.defaults.headers, _config.headers),
-    };
+        };
-    return getConfig();
+        return getConfig();
-  };
-
-  // @ts-expect-error
-  const request: Client['request'] = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      axios: options.axios ?? _config.axios ?? instance,
-      headers: mergeHeaders(_config.headers, options.headers),
     };
 
-    if (opts.security) {
+    // @ts-expect-error
-      await setAuthParams({
+    const request: Client["request"] = async options => {
-        ...opts,
+        const opts = {
-        security: opts.security,
+            ..._config,
-      });
+            ...options,
-    }
+            axios: options.axios ?? _config.axios ?? instance,
+            headers: mergeHeaders(_config.headers, options.headers),
+        };
 
-    if (opts.requestValidator) {
+        if (opts.security) {
-      await opts.requestValidator(opts);
+            await setAuthParams({
-    }
+                ...opts,
-
+                security: opts.security,
-    if (opts.body && opts.bodySerializer) {
+            });
-      opts.body = opts.bodySerializer(opts.body);
-    }
-
-    const url = buildUrl(opts);
-
-    try {
-      // assign Axios here for consistency with fetch
-      const _axios = opts.axios!;
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { auth, ...optsWithoutAuth } = opts;
-      const response = await _axios({
-        ...optsWithoutAuth,
-        baseURL: opts.baseURL as string,
-        data: opts.body,
-        headers: opts.headers as RawAxiosRequestHeaders,
-        // let `paramsSerializer()` handle query params if it exists
-        params: opts.paramsSerializer ? opts.query : undefined,
-        url,
-      });
-
-      let { data } = response;
-
-      if (opts.responseType === 'json') {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
         }
 
-        if (opts.responseTransformer) {
+        if (opts.requestValidator) {
-          data = await opts.responseTransformer(data);
+            await opts.requestValidator(opts);
         }
-      }
 
-      return {
+        if (opts.body && opts.bodySerializer) {
-        ...response,
+            opts.body = opts.bodySerializer(opts.body);
-        data: data ?? {},
+        }
-      };
-    } catch (error) {
-      const e = error as AxiosError;
-      if (opts.throwOnError) {
-        throw e;
-      }
-      // @ts-expect-error
-      e.error = e.response?.data ?? {};
-      return e;
-    }
-  };
 
-  return {
+        const url = buildUrl(opts);
-    buildUrl,
+
-    delete: (options) => request({ ...options, method: 'DELETE' }),
+        try {
-    get: (options) => request({ ...options, method: 'GET' }),
+            // assign Axios here for consistency with fetch
-    getConfig,
+            const _axios = opts.axios!;
-    head: (options) => request({ ...options, method: 'HEAD' }),
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    instance,
+            const { auth, ...optsWithoutAuth } = opts;
-    options: (options) => request({ ...options, method: 'OPTIONS' }),
+            const response = await _axios({
-    patch: (options) => request({ ...options, method: 'PATCH' }),
+                ...optsWithoutAuth,
-    post: (options) => request({ ...options, method: 'POST' }),
+                baseURL: opts.baseURL as string,
-    put: (options) => request({ ...options, method: 'PUT' }),
+                data: opts.body,
-    request,
+                headers: opts.headers as RawAxiosRequestHeaders,
-    setConfig,
+                // let `paramsSerializer()` handle query params if it exists
-  } as Client;
+                params: opts.paramsSerializer ? opts.query : undefined,
+                url,
+            });
+
+            let { data } = response;
+
+            if (opts.responseType === "json") {
+                if (opts.responseValidator) {
+                    await opts.responseValidator(data);
+                }
+
+                if (opts.responseTransformer) {
+                    data = await opts.responseTransformer(data);
+                }
+            }
+
+            return {
+                ...response,
+                data: data ?? {},
+            };
+        } catch (error) {
+            const e = error as AxiosError;
+            if (opts.throwOnError) {
+                throw e;
+            }
+            // @ts-expect-error
+            e.error = e.response?.data ?? {};
+            return e;
+        }
+    };
+
+    return {
+        buildUrl,
+        delete: options => request({ ...options, method: "DELETE" }),
+        get: options => request({ ...options, method: "GET" }),
+        getConfig,
+        head: options => request({ ...options, method: "HEAD" }),
+        instance,
+        options: options => request({ ...options, method: "OPTIONS" }),
+        patch: options => request({ ...options, method: "PATCH" }),
+        post: options => request({ ...options, method: "POST" }),
+        put: options => request({ ...options, method: "PUT" }),
+        request,
+        setConfig,
+    } as Client;
 };

src/lib/client/client/index.ts

@@ -1,21 +1,21 @@
-export type { Auth } from '../core/auth';
+export type { Auth } from "../core/auth";
-export type { QuerySerializerOptions } from '../core/bodySerializer';
+export type { QuerySerializerOptions } from "../core/bodySerializer";
 export {
-  formDataBodySerializer,
+    formDataBodySerializer,
-  jsonBodySerializer,
+    jsonBodySerializer,
-  urlSearchParamsBodySerializer,
+    urlSearchParamsBodySerializer,
-} from '../core/bodySerializer';
+} from "../core/bodySerializer";
-export { buildClientParams } from '../core/params';
+export { buildClientParams } from "../core/params";
-export { createClient } from './client';
+export { createClient } from "./client";
 export type {
-  Client,
+    Client,
-  ClientOptions,
+    ClientOptions,
-  Config,
+    Config,
-  CreateClientConfig,
+    CreateClientConfig,
-  Options,
+    Options,
-  OptionsLegacyParser,
+    OptionsLegacyParser,
-  RequestOptions,
+    RequestOptions,
-  RequestResult,
+    RequestResult,
-  TDataShape,
+    TDataShape,
-} from './types';
+} from "./types";
-export { createConfig } from './utils';
+export { createConfig } from "./utils";

src/lib/client/client/types.ts

@@ -1,138 +1,141 @@
 import type {
-  AxiosError,
+    AxiosError,
-  AxiosInstance,
+    AxiosInstance,
-  AxiosRequestHeaders,
+    AxiosRequestHeaders,
-  AxiosResponse,
+    AxiosResponse,
-  AxiosStatic,
+    AxiosStatic,
-  CreateAxiosDefaults,
+    CreateAxiosDefaults,
-} from 'axios';
+} from "axios";
-
+import type { Auth } from "../core/auth";
-import type { Auth } from '../core/auth';
+import type { Client as CoreClient, Config as CoreConfig } from "../core/types";
-import type {
-  Client as CoreClient,
-  Config as CoreConfig,
-} from '../core/types';
 
 export interface Config<T extends ClientOptions = ClientOptions>
-  extends Omit<CreateAxiosDefaults, 'auth' | 'baseURL' | 'headers' | 'method'>,
+    extends Omit<
-    CoreConfig {
+            CreateAxiosDefaults,
-  /**
+            "auth" | "baseURL" | "headers" | "method"
-   * Axios implementation. You can use this option to provide a custom
+        >,
-   * Axios instance.
+        CoreConfig {
-   *
+    /**
-   * @default axios
+     * Axios implementation. You can use this option to provide a custom
-   */
+     * Axios instance.
-  axios?: AxiosStatic;
+     *
-  /**
+     * @default axios
-   * Base URL for all requests made by this client.
+     */
-   */
+    axios?: AxiosStatic;
-  baseURL?: T['baseURL'];
+    /**
-  /**
+     * Base URL for all requests made by this client.
-   * An object containing any HTTP headers that you want to pre-populate your
+     */
-   * `Headers` object with.
+    baseURL?: T["baseURL"];
-   *
+    /**
-   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     * An object containing any HTTP headers that you want to pre-populate your
-   */
+     * `Headers` object with.
-  headers?:
+     *
-    | AxiosRequestHeaders
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
-    | Record<
+     */
-        string,
+    headers?:
-        | string
+        | AxiosRequestHeaders
-        | number
+        | Record<
-        | boolean
+              string,
-        | (string | number | boolean)[]
+              | string
-        | null
+              | number
-        | undefined
+              | boolean
-        | unknown
+              | (string | number | boolean)[]
-      >;
+              | null
-  /**
+              | undefined
-   * Throw an error instead of returning it in the response?
+              | unknown
-   *
+          >;
-   * @default false
+    /**
-   */
+     * Throw an error instead of returning it in the response?
-  throwOnError?: T['throwOnError'];
+     *
+     * @default false
+     */
+    throwOnError?: T["throwOnError"];
 }
 
 export interface RequestOptions<
-  ThrowOnError extends boolean = boolean,
+    ThrowOnError extends boolean = boolean,
-  Url extends string = string,
+    Url extends string = string,
 > extends Config<{
-    throwOnError: ThrowOnError;
+        throwOnError: ThrowOnError;
-  }> {
+    }> {
-  /**
+    /**
-   * Any body that you want to add to your request.
+     * Any body that you want to add to your request.
-   *
+     *
-   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
-   */
+     */
-  body?: unknown;
-  path?: Record<string, unknown>;
-  query?: Record<string, unknown>;
-  /**
-   * Security mechanism(s) to use for the request.
-   */
-  security?: ReadonlyArray<Auth>;
-  url: Url;
-}
-
-export type RequestResult<
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = boolean,
-> = ThrowOnError extends true
-  ? Promise<
-      AxiosResponse<
-        TData extends Record<string, unknown> ? TData[keyof TData] : TData
-      >
-    >
-  : Promise<
-      | (AxiosResponse<
-          TData extends Record<string, unknown> ? TData[keyof TData] : TData
-        > & { error: undefined })
-      | (AxiosError<
-          TError extends Record<string, unknown> ? TError[keyof TError] : TError
-        > & {
-          data: undefined;
-          error: TError extends Record<string, unknown>
-            ? TError[keyof TError]
-            : TError;
-        })
-    >;
-
-export interface ClientOptions {
-  baseURL?: string;
-  throwOnError?: boolean;
-}
-
-type MethodFn = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
->(
-  options: Omit<RequestOptions<ThrowOnError>, 'method'>,
-) => RequestResult<TData, TError, ThrowOnError>;
-
-type RequestFn = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
->(
-  options: Omit<RequestOptions<ThrowOnError>, 'method'> &
-    Pick<Required<RequestOptions<ThrowOnError>>, 'method'>,
-) => RequestResult<TData, TError, ThrowOnError>;
-
-type BuildUrlFn = <
-  TData extends {
     body?: unknown;
     path?: Record<string, unknown>;
     query?: Record<string, unknown>;
-    url: string;
+    /**
-  },
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+
+export type RequestResult<
+    TData = unknown,
+    TError = unknown,
+    ThrowOnError extends boolean = boolean,
+> = ThrowOnError extends true
+    ? Promise<
+          AxiosResponse<
+              TData extends Record<string, unknown> ? TData[keyof TData] : TData
+          >
+      >
+    : Promise<
+          | (AxiosResponse<
+                TData extends Record<string, unknown>
+                    ? TData[keyof TData]
+                    : TData
+            > & { error: undefined })
+          | (AxiosError<
+                TError extends Record<string, unknown>
+                    ? TError[keyof TError]
+                    : TError
+            > & {
+                data: undefined;
+                error: TError extends Record<string, unknown>
+                    ? TError[keyof TError]
+                    : TError;
+            })
+      >;
+
+export interface ClientOptions {
+    baseURL?: string;
+    throwOnError?: boolean;
+}
+
+type MethodFn = <
+    TData = unknown,
+    TError = unknown,
+    ThrowOnError extends boolean = false,
 >(
-  options: Pick<TData, 'url'> & Omit<Options<TData>, 'axios'>,
+    options: Omit<RequestOptions<ThrowOnError>, "method">
+) => RequestResult<TData, TError, ThrowOnError>;
+
+type RequestFn = <
+    TData = unknown,
+    TError = unknown,
+    ThrowOnError extends boolean = false,
+>(
+    options: Omit<RequestOptions<ThrowOnError>, "method"> &
+        Pick<Required<RequestOptions<ThrowOnError>>, "method">
+) => RequestResult<TData, TError, ThrowOnError>;
+
+type BuildUrlFn = <
+    TData extends {
+        body?: unknown;
+        path?: Record<string, unknown>;
+        query?: Record<string, unknown>;
+        url: string;
+    },
+>(
+    options: Pick<TData, "url"> & Omit<Options<TData>, "axios">
 ) => string;
 
 export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
-  instance: AxiosInstance;
+    instance: AxiosInstance;
 };
 
 /**
@@ -144,36 +147,37 @@ export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
  * to ensure your client always has the correct values.
  */
 export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
-  override?: Config<ClientOptions & T>,
+    override?: Config<ClientOptions & T>
 ) => Config<Required<ClientOptions> & T>;
 
 export interface TDataShape {
-  body?: unknown;
+    body?: unknown;
-  headers?: unknown;
+    headers?: unknown;
-  path?: unknown;
+    path?: unknown;
-  query?: unknown;
+    query?: unknown;
-  url: string;
+    url: string;
 }
 
 type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
 
 export type Options<
-  TData extends TDataShape = TDataShape,
+    TData extends TDataShape = TDataShape,
-  ThrowOnError extends boolean = boolean,
+    ThrowOnError extends boolean = boolean,
-> = OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'path' | 'query' | 'url'> &
+> = OmitKeys<RequestOptions<ThrowOnError>, "body" | "path" | "query" | "url"> &
-  Omit<TData, 'url'>;
+    Omit<TData, "url">;
 
 export type OptionsLegacyParser<
-  TData = unknown,
+    TData = unknown,
-  ThrowOnError extends boolean = boolean,
+    ThrowOnError extends boolean = boolean,
 > = TData extends { body?: any }
-  ? TData extends { headers?: any }
+    ? TData extends { headers?: any }
-    ? OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'headers' | 'url'> & TData
+        ? OmitKeys<RequestOptions<ThrowOnError>, "body" | "headers" | "url"> &
-    : OmitKeys<RequestOptions<ThrowOnError>, 'body' | 'url'> &
+              TData
-        TData &
+        : OmitKeys<RequestOptions<ThrowOnError>, "body" | "url"> &
-        Pick<RequestOptions<ThrowOnError>, 'headers'>
+              TData &
-  : TData extends { headers?: any }
+              Pick<RequestOptions<ThrowOnError>, "headers">
-    ? OmitKeys<RequestOptions<ThrowOnError>, 'headers' | 'url'> &
+    : TData extends { headers?: any }
-        TData &
+      ? OmitKeys<RequestOptions<ThrowOnError>, "headers" | "url"> &
-        Pick<RequestOptions<ThrowOnError>, 'body'>
+            TData &
-    : OmitKeys<RequestOptions<ThrowOnError>, 'url'> & TData;
+            Pick<RequestOptions<ThrowOnError>, "body">
+      : OmitKeys<RequestOptions<ThrowOnError>, "url"> & TData;

src/lib/client/client/utils.ts

@@ -1,286 +1,292 @@
-import { getAuthToken } from '../core/auth';
+import { getAuthToken } from "../core/auth";
 import type {
-  QuerySerializer,
+    QuerySerializer,
-  QuerySerializerOptions,
+    QuerySerializerOptions,
-} from '../core/bodySerializer';
+} from "../core/bodySerializer";
-import type { ArraySeparatorStyle } from '../core/pathSerializer';
+import type { ArraySeparatorStyle } from "../core/pathSerializer";
 import {
-  serializeArrayParam,
+    serializeArrayParam,
-  serializeObjectParam,
+    serializeObjectParam,
-  serializePrimitiveParam,
+    serializePrimitiveParam,
-} from '../core/pathSerializer';
+} from "../core/pathSerializer";
-import type { Client, ClientOptions, Config, RequestOptions } from './types';
+import type { Client, ClientOptions, Config, RequestOptions } from "./types";
 
 interface PathSerializer {
-  path: Record<string, unknown>;
+    path: Record<string, unknown>;
-  url: string;
+    url: string;
 }
 
 const PATH_PARAM_RE = /\{[^{}]+\}/g;
 
 const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
-  let url = _url;
+    let url = _url;
-  const matches = _url.match(PATH_PARAM_RE);
+    const matches = _url.match(PATH_PARAM_RE);
-  if (matches) {
+    if (matches) {
-    for (const match of matches) {
+        for (const match of matches) {
-      let explode = false;
+            let explode = false;
-      let name = match.substring(1, match.length - 1);
+            let name = match.substring(1, match.length - 1);
-      let style: ArraySeparatorStyle = 'simple';
+            let style: ArraySeparatorStyle = "simple";
 
-      if (name.endsWith('*')) {
+            if (name.endsWith("*")) {
-        explode = true;
+                explode = true;
-        name = name.substring(0, name.length - 1);
+                name = name.substring(0, name.length - 1);
-      }
+            }
 
-      if (name.startsWith('.')) {
+            if (name.startsWith(".")) {
-        name = name.substring(1);
+                name = name.substring(1);
-        style = 'label';
+                style = "label";
-      } else if (name.startsWith(';')) {
+            } else if (name.startsWith(";")) {
-        name = name.substring(1);
+                name = name.substring(1);
-        style = 'matrix';
+                style = "matrix";
-      }
+            }
 
-      const value = path[name];
+            const value = path[name];
 
-      if (value === undefined || value === null) {
+            if (value === undefined || value === null) {
-        continue;
+                continue;
-      }
+            }
 
-      if (Array.isArray(value)) {
+            if (Array.isArray(value)) {
-        url = url.replace(
+                url = url.replace(
-          match,
+                    match,
-          serializeArrayParam({ explode, name, style, value }),
+                    serializeArrayParam({ explode, name, style, value })
-        );
+                );
-        continue;
+                continue;
-      }
+            }
 
-      if (typeof value === 'object') {
+            if (typeof value === "object") {
-        url = url.replace(
+                url = url.replace(
-          match,
+                    match,
-          serializeObjectParam({
+                    serializeObjectParam({
-            explode,
+                        explode,
-            name,
+                        name,
-            style,
+                        style,
-            value: value as Record<string, unknown>,
+                        value: value as Record<string, unknown>,
-            valueOnly: true,
+                        valueOnly: true,
-          }),
+                    })
-        );
+                );
-        continue;
+                continue;
-      }
+            }
 
-      if (style === 'matrix') {
+            if (style === "matrix") {
-        url = url.replace(
+                url = url.replace(
-          match,
+                    match,
-          `;${serializePrimitiveParam({
+                    `;${serializePrimitiveParam({
-            name,
+                        name,
-            value: value as string,
+                        value: value as string,
-          })}`,
+                    })}`
-        );
+                );
-        continue;
+                continue;
-      }
+            }
 
-      const replaceValue = encodeURIComponent(
+            const replaceValue = encodeURIComponent(
-        style === 'label' ? `.${value as string}` : (value as string),
+                style === "label" ? `.${value as string}` : (value as string)
-      );
+            );
-      url = url.replace(match, replaceValue);
+            url = url.replace(match, replaceValue);
+        }
     }
-  }
+    return url;
-  return url;
 };
 
 export const createQuerySerializer = <T = unknown>({
-  allowReserved,
+    allowReserved,
-  array,
+    array,
-  object,
+    object,
 }: QuerySerializerOptions = {}) => {
-  const querySerializer = (queryParams: T) => {
+    const querySerializer = (queryParams: T) => {
-    const search: string[] = [];
+        const search: string[] = [];
-    if (queryParams && typeof queryParams === 'object') {
+        if (queryParams && typeof queryParams === "object") {
-      for (const name in queryParams) {
+            for (const name in queryParams) {
-        const value = queryParams[name];
+                const value = queryParams[name];
 
-        if (value === undefined || value === null) {
+                if (value === undefined || value === null) {
-          continue;
+                    continue;
-        }
+                }
 
-        if (Array.isArray(value)) {
+                if (Array.isArray(value)) {
-          const serializedArray = serializeArrayParam({
+                    const serializedArray = serializeArrayParam({
-            allowReserved,
+                        allowReserved,
-            explode: true,
+                        explode: true,
-            name,
+                        name,
-            style: 'form',
+                        style: "form",
-            value,
+                        value,
-            ...array,
+                        ...array,
-          });
+                    });
-          if (serializedArray) search.push(serializedArray);
+                    if (serializedArray) search.push(serializedArray);
-        } else if (typeof value === 'object') {
+                } else if (typeof value === "object") {
-          const serializedObject = serializeObjectParam({
+                    const serializedObject = serializeObjectParam({
-            allowReserved,
+                        allowReserved,
-            explode: true,
+                        explode: true,
-            name,
+                        name,
-            style: 'deepObject',
+                        style: "deepObject",
-            value: value as Record<string, unknown>,
+                        value: value as Record<string, unknown>,
-            ...object,
+                        ...object,
-          });
+                    });
-          if (serializedObject) search.push(serializedObject);
+                    if (serializedObject) search.push(serializedObject);
-        } else {
+                } else {
-          const serializedPrimitive = serializePrimitiveParam({
+                    const serializedPrimitive = serializePrimitiveParam({
-            allowReserved,
+                        allowReserved,
-            name,
+                        name,
-            value: value as string,
+                        value: value as string,
-          });
+                    });
-          if (serializedPrimitive) search.push(serializedPrimitive);
+                    if (serializedPrimitive) search.push(serializedPrimitive);
+                }
+            }
         }
-      }
+        return search.join("&");
-    }
+    };
-    return search.join('&');
+    return querySerializer;
-  };
-  return querySerializer;
 };
 
 export const setAuthParams = async ({
-  security,
+    security,
-  ...options
+    ...options
-}: Pick<Required<RequestOptions>, 'security'> &
+}: Pick<Required<RequestOptions>, "security"> &
-  Pick<RequestOptions, 'auth' | 'query'> & {
+    Pick<RequestOptions, "auth" | "query"> & {
-    headers: Record<any, unknown>;
+        headers: Record<any, unknown>;
-  }) => {
+    }) => {
-  for (const auth of security) {
+    for (const auth of security) {
-    const token = await getAuthToken(auth, options.auth);
+        const token = await getAuthToken(auth, options.auth);
 
-    if (!token) {
+        if (!token) {
-      continue;
+            continue;
-    }
-
-    const name = auth.name ?? 'Authorization';
-
-    switch (auth.in) {
-      case 'query':
-        if (!options.query) {
-          options.query = {};
         }
-        options.query[name] = token;
-        break;
-      case 'cookie': {
-        const value = `${name}=${token}`;
-        if ('Cookie' in options.headers && options.headers['Cookie']) {
-          options.headers['Cookie'] = `${options.headers['Cookie']}; ${value}`;
-        } else {
-          options.headers['Cookie'] = value;
-        }
-        break;
-      }
-      case 'header':
-      default:
-        options.headers[name] = token;
-        break;
-    }
 
-    return;
+        const name = auth.name ?? "Authorization";
-  }
+
+        switch (auth.in) {
+            case "query":
+                if (!options.query) {
+                    options.query = {};
+                }
+                options.query[name] = token;
+                break;
+            case "cookie": {
+                const value = `${name}=${token}`;
+                if ("Cookie" in options.headers && options.headers["Cookie"]) {
+                    options.headers["Cookie"] =
+                        `${options.headers["Cookie"]}; ${value}`;
+                } else {
+                    options.headers["Cookie"] = value;
+                }
+                break;
+            }
+            case "header":
+            default:
+                options.headers[name] = token;
+                break;
+        }
+
+        return;
+    }
 };
 
-export const buildUrl: Client['buildUrl'] = (options) => {
+export const buildUrl: Client["buildUrl"] = options => {
-  const url = getUrl({
+    const url = getUrl({
-    path: options.path,
+        path: options.path,
-    // let `paramsSerializer()` handle query params if it exists
+        // let `paramsSerializer()` handle query params if it exists
-    query: !options.paramsSerializer ? options.query : undefined,
+        query: !options.paramsSerializer ? options.query : undefined,
-    querySerializer:
+        querySerializer:
-      typeof options.querySerializer === 'function'
+            typeof options.querySerializer === "function"
-        ? options.querySerializer
+                ? options.querySerializer
-        : createQuerySerializer(options.querySerializer),
+                : createQuerySerializer(options.querySerializer),
-    url: options.url,
+        url: options.url,
-  });
+    });
-  return url;
+    return url;
 };
 
 export const getUrl = ({
-  path,
+    path,
-  query,
+    query,
-  querySerializer,
+    querySerializer,
-  url: _url,
+    url: _url,
 }: {
-  path?: Record<string, unknown>;
+    path?: Record<string, unknown>;
-  query?: Record<string, unknown>;
+    query?: Record<string, unknown>;
-  querySerializer: QuerySerializer;
+    querySerializer: QuerySerializer;
-  url: string;
+    url: string;
 }) => {
-  const pathUrl = _url.startsWith('/') ? _url : `/${_url}`;
+    const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
-  let url = pathUrl;
+    let url = pathUrl;
-  if (path) {
+    if (path) {
-    url = defaultPathSerializer({ path, url });
+        url = defaultPathSerializer({ path, url });
-  }
+    }
-  let search = query ? querySerializer(query) : '';
+    let search = query ? querySerializer(query) : "";
-  if (search.startsWith('?')) {
+    if (search.startsWith("?")) {
-    search = search.substring(1);
+        search = search.substring(1);
-  }
+    }
-  if (search) {
+    if (search) {
-    url += `?${search}`;
+        url += `?${search}`;
-  }
+    }
-  return url;
+    return url;
 };
 
 export const mergeConfigs = (a: Config, b: Config): Config => {
-  const config = { ...a, ...b };
+    const config = { ...a, ...b };
-  config.headers = mergeHeaders(a.headers, b.headers);
+    config.headers = mergeHeaders(a.headers, b.headers);
-  return config;
+    return config;
 };
 
 /**
  * Special Axios headers keywords allowing to set headers by request method.
  */
 export const axiosHeadersKeywords = [
-  'common',
+    "common",
-  'delete',
+    "delete",
-  'get',
+    "get",
-  'head',
+    "head",
-  'patch',
+    "patch",
-  'post',
+    "post",
-  'put',
+    "put",
 ] as const;
 
 export const mergeHeaders = (
-  ...headers: Array<Required<Config>['headers'] | undefined>
+    ...headers: Array<Required<Config>["headers"] | undefined>
 ): Record<any, unknown> => {
-  const mergedHeaders: Record<any, unknown> = {};
+    const mergedHeaders: Record<any, unknown> = {};
-  for (const header of headers) {
+    for (const header of headers) {
-    if (!header || typeof header !== 'object') {
+        if (!header || typeof header !== "object") {
-      continue;
+            continue;
-    }
+        }
-
+
-    const iterator = Object.entries(header);
+        const iterator = Object.entries(header);
-
+
-    for (const [key, value] of iterator) {
+        for (const [key, value] of iterator) {
-      if (
+            if (
-        axiosHeadersKeywords.includes(
+                axiosHeadersKeywords.includes(
-          key as (typeof axiosHeadersKeywords)[number],
+                    key as (typeof axiosHeadersKeywords)[number]
-        ) &&
+                ) &&
-        typeof value === 'object'
+                typeof value === "object"
-      ) {
+            ) {
-        mergedHeaders[key] = {
+                mergedHeaders[key] = {
-          ...(mergedHeaders[key] as Record<any, unknown>),
+                    ...(mergedHeaders[key] as Record<any, unknown>),
-          ...value,
+                    ...value,
-        };
+                };
-      } else if (value === null) {
+            } else if (value === null) {
-        delete mergedHeaders[key];
+                delete mergedHeaders[key];
-      } else if (Array.isArray(value)) {
+            } else if (Array.isArray(value)) {
-        for (const v of value) {
+                for (const v of value) {
-          // @ts-expect-error
+                    // @ts-expect-error
-          mergedHeaders[key] = [...(mergedHeaders[key] ?? []), v as string];
+                    mergedHeaders[key] = [
+                        ...(mergedHeaders[key] ?? []),
+                        v as string,
+                    ];
+                }
+            } else if (value !== undefined) {
+                // assume object headers are meant to be JSON stringified, i.e. their
+                // content value in OpenAPI specification is 'application/json'
+                mergedHeaders[key] =
+                    typeof value === "object"
+                        ? JSON.stringify(value)
+                        : (value as string);
+            }
         }
-      } else if (value !== undefined) {
-        // assume object headers are meant to be JSON stringified, i.e. their
-        // content value in OpenAPI specification is 'application/json'
-        mergedHeaders[key] =
-          typeof value === 'object' ? JSON.stringify(value) : (value as string);
-      }
     }
-  }
+    return mergedHeaders;
-  return mergedHeaders;
 };
 
 export const createConfig = <T extends ClientOptions = ClientOptions>(
-  override: Config<Omit<ClientOptions, keyof T> & T> = {},
+    override: Config<Omit<ClientOptions, keyof T> & T> = {}
 ): Config<Omit<ClientOptions, keyof T> & T> => ({
-  ...override,
+    ...override,
 });

src/lib/client/core/auth.ts

@@ -1,40 +1,40 @@
 export type AuthToken = string | undefined;
 
 export interface Auth {
-  /**
+    /**
-   * Which part of the request do we use to send the auth?
+     * Which part of the request do we use to send the auth?
-   *
+     *
-   * @default 'header'
+     * @default 'header'
-   */
+     */
-  in?: 'header' | 'query' | 'cookie';
+    in?: "header" | "query" | "cookie";
-  /**
+    /**
-   * Header or query parameter name.
+     * Header or query parameter name.
-   *
+     *
-   * @default 'Authorization'
+     * @default 'Authorization'
-   */
+     */
-  name?: string;
+    name?: string;
-  scheme?: 'basic' | 'bearer';
+    scheme?: "basic" | "bearer";
-  type: 'apiKey' | 'http';
+    type: "apiKey" | "http";
 }
 
 export const getAuthToken = async (
-  auth: Auth,
+    auth: Auth,
-  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+    callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken
 ): Promise<string | undefined> => {
-  const token =
+    const token =
-    typeof callback === 'function' ? await callback(auth) : callback;
+        typeof callback === "function" ? await callback(auth) : callback;
 
-  if (!token) {
+    if (!token) {
-    return;
+        return;
-  }
+    }
 
-  if (auth.scheme === 'bearer') {
+    if (auth.scheme === "bearer") {
-    return `Bearer ${token}`;
+        return `Bearer ${token}`;
-  }
+    }
 
-  if (auth.scheme === 'basic') {
+    if (auth.scheme === "basic") {
-    return `Basic ${btoa(token)}`;
+        return `Basic ${btoa(token)}`;
-  }
+    }
 
-  return token;
+    return token;
 };

src/lib/client/core/bodySerializer.ts

@@ -1,88 +1,92 @@
 import type {
-  ArrayStyle,
+    ArrayStyle,
-  ObjectStyle,
+    ObjectStyle,
-  SerializerOptions,
+    SerializerOptions,
-} from './pathSerializer';
+} from "./pathSerializer";
 
 export type QuerySerializer = (query: Record<string, unknown>) => string;
 
 export type BodySerializer = (body: any) => any;
 
 export interface QuerySerializerOptions {
-  allowReserved?: boolean;
+    allowReserved?: boolean;
-  array?: SerializerOptions<ArrayStyle>;
+    array?: SerializerOptions<ArrayStyle>;
-  object?: SerializerOptions<ObjectStyle>;
+    object?: SerializerOptions<ObjectStyle>;
 }
 
 const serializeFormDataPair = (
-  data: FormData,
+    data: FormData,
-  key: string,
+    key: string,
-  value: unknown,
+    value: unknown
 ): void => {
-  if (typeof value === 'string' || value instanceof Blob) {
+    if (typeof value === "string" || value instanceof Blob) {
-    data.append(key, value);
+        data.append(key, value);
-  } else {
+    } else {
-    data.append(key, JSON.stringify(value));
+        data.append(key, JSON.stringify(value));
-  }
+    }
 };
 
 const serializeUrlSearchParamsPair = (
-  data: URLSearchParams,
+    data: URLSearchParams,
-  key: string,
+    key: string,
-  value: unknown,
+    value: unknown
 ): void => {
-  if (typeof value === 'string') {
+    if (typeof value === "string") {
-    data.append(key, value);
+        data.append(key, value);
-  } else {
+    } else {
-    data.append(key, JSON.stringify(value));
+        data.append(key, JSON.stringify(value));
-  }
+    }
 };
 
 export const formDataBodySerializer = {
-  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    bodySerializer: <
-    body: T,
+        T extends Record<string, any> | Array<Record<string, any>>,
-  ): FormData => {
+    >(
-    const data = new FormData();
+        body: T
+    ): FormData => {
+        const data = new FormData();
 
-    Object.entries(body).forEach(([key, value]) => {
+        Object.entries(body).forEach(([key, value]) => {
-      if (value === undefined || value === null) {
+            if (value === undefined || value === null) {
-        return;
+                return;
-      }
+            }
-      if (Array.isArray(value)) {
+            if (Array.isArray(value)) {
-        value.forEach((v) => serializeFormDataPair(data, key, v));
+                value.forEach(v => serializeFormDataPair(data, key, v));
-      } else {
+            } else {
-        serializeFormDataPair(data, key, value);
+                serializeFormDataPair(data, key, value);
-      }
+            }
-    });
+        });
 
-    return data;
+        return data;
-  },
+    },
 };
 
 export const jsonBodySerializer = {
-  bodySerializer: <T>(body: T): string =>
+    bodySerializer: <T>(body: T): string =>
-    JSON.stringify(body, (_key, value) =>
+        JSON.stringify(body, (_key, value) =>
-      typeof value === 'bigint' ? value.toString() : value,
+            typeof value === "bigint" ? value.toString() : value
-    ),
+        ),
 };
 
 export const urlSearchParamsBodySerializer = {
-  bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+    bodySerializer: <
-    body: T,
+        T extends Record<string, any> | Array<Record<string, any>>,
-  ): string => {
+    >(
-    const data = new URLSearchParams();
+        body: T
+    ): string => {
+        const data = new URLSearchParams();
 
-    Object.entries(body).forEach(([key, value]) => {
+        Object.entries(body).forEach(([key, value]) => {
-      if (value === undefined || value === null) {
+            if (value === undefined || value === null) {
-        return;
+                return;
-      }
+            }
-      if (Array.isArray(value)) {
+            if (Array.isArray(value)) {
-        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+                value.forEach(v => serializeUrlSearchParamsPair(data, key, v));
-      } else {
+            } else {
-        serializeUrlSearchParamsPair(data, key, value);
+                serializeUrlSearchParamsPair(data, key, value);
-      }
+            }
-    });
+        });
 
-    return data.toString();
+        return data.toString();
-  },
+    },
 };

src/lib/client/core/params.ts

@@ -1,151 +1,156 @@
-type Slot = 'body' | 'headers' | 'path' | 'query';
+type Slot = "body" | "headers" | "path" | "query";
 
 export type Field =
-  | {
+    | {
-      in: Exclude<Slot, 'body'>;
+          in: Exclude<Slot, "body">;
-      /**
+          /**
-       * Field name. This is the name we want the user to see and use.
+           * Field name. This is the name we want the user to see and use.
-       */
+           */
-      key: string;
+          key: string;
-      /**
+          /**
-       * Field mapped name. This is the name we want to use in the request.
+           * Field mapped name. This is the name we want to use in the request.
-       * If omitted, we use the same value as `key`.
+           * If omitted, we use the same value as `key`.
-       */
+           */
-      map?: string;
+          map?: string;
-    }
+      }
-  | {
+    | {
-      in: Extract<Slot, 'body'>;
+          in: Extract<Slot, "body">;
-      /**
+          /**
-       * Key isn't required for bodies.
+           * Key isn't required for bodies.
-       */
+           */
-      key?: string;
+          key?: string;
-      map?: string;
+          map?: string;
-    };
+      };
 
 export interface Fields {
-  allowExtra?: Partial<Record<Slot, boolean>>;
+    allowExtra?: Partial<Record<Slot, boolean>>;
-  args?: ReadonlyArray<Field>;
+    args?: ReadonlyArray<Field>;
 }
 
 export type FieldsConfig = ReadonlyArray<Field | Fields>;
 
 const extraPrefixesMap: Record<string, Slot> = {
-  $body_: 'body',
+    $body_: "body",
-  $headers_: 'headers',
+    $headers_: "headers",
-  $path_: 'path',
+    $path_: "path",
-  $query_: 'query',
+    $query_: "query",
 };
 const extraPrefixes = Object.entries(extraPrefixesMap);
 
 type KeyMap = Map<
-  string,
+    string,
-  {
+    {
-    in: Slot;
+        in: Slot;
-    map?: string;
+        map?: string;
-  }
+    }
 >;
 
 const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
-  if (!map) {
+    if (!map) {
-    map = new Map();
+        map = new Map();
-  }
-
-  for (const config of fields) {
-    if ('in' in config) {
-      if (config.key) {
-        map.set(config.key, {
-          in: config.in,
-          map: config.map,
-        });
-      }
-    } else if (config.args) {
-      buildKeyMap(config.args, map);
     }
-  }
 
-  return map;
+    for (const config of fields) {
+        if ("in" in config) {
+            if (config.key) {
+                map.set(config.key, {
+                    in: config.in,
+                    map: config.map,
+                });
+            }
+        } else if (config.args) {
+            buildKeyMap(config.args, map);
+        }
+    }
+
+    return map;
 };
 
 interface Params {
-  body: unknown;
+    body: unknown;
-  headers: Record<string, unknown>;
+    headers: Record<string, unknown>;
-  path: Record<string, unknown>;
+    path: Record<string, unknown>;
-  query: Record<string, unknown>;
+    query: Record<string, unknown>;
 }
 
 const stripEmptySlots = (params: Params) => {
-  for (const [slot, value] of Object.entries(params)) {
+    for (const [slot, value] of Object.entries(params)) {
-    if (value && typeof value === 'object' && !Object.keys(value).length) {
+        if (value && typeof value === "object" && !Object.keys(value).length) {
-      delete params[slot as Slot];
+            delete params[slot as Slot];
+        }
     }
-  }
 };
 
 export const buildClientParams = (
-  args: ReadonlyArray<unknown>,
+    args: ReadonlyArray<unknown>,
-  fields: FieldsConfig,
+    fields: FieldsConfig
 ) => {
-  const params: Params = {
+    const params: Params = {
-    body: {},
+        body: {},
-    headers: {},
+        headers: {},
-    path: {},
+        path: {},
-    query: {},
+        query: {},
-  };
+    };
 
-  const map = buildKeyMap(fields);
+    const map = buildKeyMap(fields);
 
-  let config: FieldsConfig[number] | undefined;
+    let config: FieldsConfig[number] | undefined;
 
-  for (const [index, arg] of args.entries()) {
+    for (const [index, arg] of args.entries()) {
-    if (fields[index]) {
+        if (fields[index]) {
-      config = fields[index];
+            config = fields[index];
-    }
+        }
-
+
-    if (!config) {
+        if (!config) {
-      continue;
+            continue;
-    }
+        }
-
+
-    if ('in' in config) {
+        if ("in" in config) {
-      if (config.key) {
+            if (config.key) {
-        const field = map.get(config.key)!;
+                const field = map.get(config.key)!;
-        const name = field.map || config.key;
+                const name = field.map || config.key;
-        (params[field.in] as Record<string, unknown>)[name] = arg;
+                (params[field.in] as Record<string, unknown>)[name] = arg;
-      } else {
+            } else {
-        params.body = arg;
+                params.body = arg;
-      }
+            }
-    } else {
+        } else {
-      for (const [key, value] of Object.entries(arg ?? {})) {
+            for (const [key, value] of Object.entries(arg ?? {})) {
-        const field = map.get(key);
+                const field = map.get(key);
-
+
-        if (field) {
+                if (field) {
-          const name = field.map || key;
+                    const name = field.map || key;
-          (params[field.in] as Record<string, unknown>)[name] = value;
+                    (params[field.in] as Record<string, unknown>)[name] = value;
-        } else {
+                } else {
-          const extra = extraPrefixes.find(([prefix]) =>
+                    const extra = extraPrefixes.find(([prefix]) =>
-            key.startsWith(prefix),
+                        key.startsWith(prefix)
-          );
+                    );
-
+
-          if (extra) {
+                    if (extra) {
-            const [prefix, slot] = extra;
+                        const [prefix, slot] = extra;
-            (params[slot] as Record<string, unknown>)[
+                        (params[slot] as Record<string, unknown>)[
-              key.slice(prefix.length)
+                            key.slice(prefix.length)
-            ] = value;
+                        ] = value;
-          } else {
+                    } else {
-            for (const [slot, allowed] of Object.entries(
+                        for (const [slot, allowed] of Object.entries(
-              config.allowExtra ?? {},
+                            config.allowExtra ?? {}
-            )) {
+                        )) {
-              if (allowed) {
+                            if (allowed) {
-                (params[slot as Slot] as Record<string, unknown>)[key] = value;
+                                (
-                break;
+                                    params[slot as Slot] as Record<
-              }
+                                        string,
-            }
+                                        unknown
-          }
+                                    >
+                                )[key] = value;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
         }
-      }
     }
-  }
 
-  stripEmptySlots(params);
+    stripEmptySlots(params);
 
-  return params;
+    return params;
 };

src/lib/client/core/pathSerializer.ts

@@ -1,179 +1,183 @@
 interface SerializeOptions<T>
-  extends SerializePrimitiveOptions,
+    extends SerializePrimitiveOptions,
-    SerializerOptions<T> {}
+        SerializerOptions<T> {}
 
 interface SerializePrimitiveOptions {
-  allowReserved?: boolean;
+    allowReserved?: boolean;
-  name: string;
+    name: string;
 }
 
 export interface SerializerOptions<T> {
-  /**
+    /**
-   * @default true
+     * @default true
-   */
+     */
-  explode: boolean;
+    explode: boolean;
-  style: T;
+    style: T;
 }
 
-export type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+export type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
 export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
-type MatrixStyle = 'label' | 'matrix' | 'simple';
+type MatrixStyle = "label" | "matrix" | "simple";
-export type ObjectStyle = 'form' | 'deepObject';
+export type ObjectStyle = "form" | "deepObject";
 type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
 
 interface SerializePrimitiveParam extends SerializePrimitiveOptions {
-  value: string;
+    value: string;
 }
 
 export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
-  switch (style) {
+    switch (style) {
-    case 'label':
+        case "label":
-      return '.';
+            return ".";
-    case 'matrix':
+        case "matrix":
-      return ';';
+            return ";";
-    case 'simple':
+        case "simple":
-      return ',';
+            return ",";
-    default:
+        default:
-      return '&';
+            return "&";
-  }
+    }
 };
 
 export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
-  switch (style) {
+    switch (style) {
-    case 'form':
+        case "form":
-      return ',';
+            return ",";
-    case 'pipeDelimited':
+        case "pipeDelimited":
-      return '|';
+            return "|";
-    case 'spaceDelimited':
+        case "spaceDelimited":
-      return '%20';
+            return "%20";
-    default:
+        default:
-      return ',';
+            return ",";
-  }
+    }
 };
 
 export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
-  switch (style) {
+    switch (style) {
-    case 'label':
+        case "label":
-      return '.';
+            return ".";
-    case 'matrix':
+        case "matrix":
-      return ';';
+            return ";";
-    case 'simple':
+        case "simple":
-      return ',';
+            return ",";
-    default:
+        default:
-      return '&';
+            return "&";
-  }
+    }
 };
 
 export const serializeArrayParam = ({
-  allowReserved,
+    allowReserved,
-  explode,
+    explode,
-  name,
+    name,
-  style,
+    style,
-  value,
+    value,
 }: SerializeOptions<ArraySeparatorStyle> & {
-  value: unknown[];
+    value: unknown[];
 }) => {
-  if (!explode) {
+    if (!explode) {
-    const joinedValues = (
+        const joinedValues = (
-      allowReserved ? value : value.map((v) => encodeURIComponent(v as string))
+            allowReserved
-    ).join(separatorArrayNoExplode(style));
+                ? value
-    switch (style) {
+                : value.map(v => encodeURIComponent(v as string))
-      case 'label':
+        ).join(separatorArrayNoExplode(style));
-        return `.${joinedValues}`;
+        switch (style) {
-      case 'matrix':
+            case "label":
-        return `;${name}=${joinedValues}`;
+                return `.${joinedValues}`;
-      case 'simple':
+            case "matrix":
-        return joinedValues;
+                return `;${name}=${joinedValues}`;
-      default:
+            case "simple":
-        return `${name}=${joinedValues}`;
+                return joinedValues;
+            default:
+                return `${name}=${joinedValues}`;
+        }
     }
-  }
 
-  const separator = separatorArrayExplode(style);
+    const separator = separatorArrayExplode(style);
-  const joinedValues = value
+    const joinedValues = value
-    .map((v) => {
+        .map(v => {
-      if (style === 'label' || style === 'simple') {
+            if (style === "label" || style === "simple") {
-        return allowReserved ? v : encodeURIComponent(v as string);
+                return allowReserved ? v : encodeURIComponent(v as string);
-      }
+            }
 
-      return serializePrimitiveParam({
+            return serializePrimitiveParam({
-        allowReserved,
+                allowReserved,
-        name,
+                name,
-        value: v as string,
+                value: v as string,
-      });
+            });
-    })
+        })
-    .join(separator);
+        .join(separator);
-  return style === 'label' || style === 'matrix'
+    return style === "label" || style === "matrix"
-    ? separator + joinedValues
+        ? separator + joinedValues
-    : joinedValues;
+        : joinedValues;
 };
 
 export const serializePrimitiveParam = ({
-  allowReserved,
+    allowReserved,
-  name,
+    name,
-  value,
+    value,
 }: SerializePrimitiveParam) => {
-  if (value === undefined || value === null) {
+    if (value === undefined || value === null) {
-    return '';
+        return "";
-  }
+    }
 
-  if (typeof value === 'object') {
+    if (typeof value === "object") {
-    throw new Error(
+        throw new Error(
-      'Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.',
+            "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these."
-    );
+        );
-  }
+    }
 
-  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+    return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
 };
 
 export const serializeObjectParam = ({
-  allowReserved,
+    allowReserved,
-  explode,
+    explode,
-  name,
+    name,
-  style,
+    style,
-  value,
+    value,
-  valueOnly,
+    valueOnly,
 }: SerializeOptions<ObjectSeparatorStyle> & {
-  value: Record<string, unknown> | Date;
+    value: Record<string, unknown> | Date;
-  valueOnly?: boolean;
+    valueOnly?: boolean;
 }) => {
-  if (value instanceof Date) {
+    if (value instanceof Date) {
-    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+        return valueOnly
-  }
+            ? value.toISOString()
-
+            : `${name}=${value.toISOString()}`;
-  if (style !== 'deepObject' && !explode) {
-    let values: string[] = [];
-    Object.entries(value).forEach(([key, v]) => {
-      values = [
-        ...values,
-        key,
-        allowReserved ? (v as string) : encodeURIComponent(v as string),
-      ];
-    });
-    const joinedValues = values.join(',');
-    switch (style) {
-      case 'form':
-        return `${name}=${joinedValues}`;
-      case 'label':
-        return `.${joinedValues}`;
-      case 'matrix':
-        return `;${name}=${joinedValues}`;
-      default:
-        return joinedValues;
     }
-  }
 
-  const separator = separatorObjectExplode(style);
+    if (style !== "deepObject" && !explode) {
-  const joinedValues = Object.entries(value)
+        let values: string[] = [];
-    .map(([key, v]) =>
+        Object.entries(value).forEach(([key, v]) => {
-      serializePrimitiveParam({
+            values = [
-        allowReserved,
+                ...values,
-        name: style === 'deepObject' ? `${name}[${key}]` : key,
+                key,
-        value: v as string,
+                allowReserved ? (v as string) : encodeURIComponent(v as string),
-      }),
+            ];
-    )
+        });
-    .join(separator);
+        const joinedValues = values.join(",");
-  return style === 'label' || style === 'matrix'
+        switch (style) {
-    ? separator + joinedValues
+            case "form":
-    : joinedValues;
+                return `${name}=${joinedValues}`;
+            case "label":
+                return `.${joinedValues}`;
+            case "matrix":
+                return `;${name}=${joinedValues}`;
+            default:
+                return joinedValues;
+        }
+    }
+
+    const separator = separatorObjectExplode(style);
+    const joinedValues = Object.entries(value)
+        .map(([key, v]) =>
+            serializePrimitiveParam({
+                allowReserved,
+                name: style === "deepObject" ? `${name}[${key}]` : key,
+                value: v as string,
+            })
+        )
+        .join(separator);
+    return style === "label" || style === "matrix"
+        ? separator + joinedValues
+        : joinedValues;
 };

src/lib/client/core/types.ts

@@ -1,118 +1,118 @@
-import type { Auth, AuthToken } from './auth';
+import type { Auth, AuthToken } from "./auth";
 import type {
-  BodySerializer,
+    BodySerializer,
-  QuerySerializer,
+    QuerySerializer,
-  QuerySerializerOptions,
+    QuerySerializerOptions,
-} from './bodySerializer';
+} from "./bodySerializer";
 
 export interface Client<
-  RequestFn = never,
+    RequestFn = never,
-  Config = unknown,
+    Config = unknown,
-  MethodFn = never,
+    MethodFn = never,
-  BuildUrlFn = never,
+    BuildUrlFn = never,
 > {
-  /**
+    /**
-   * Returns the final request URL.
+     * Returns the final request URL.
-   */
+     */
-  buildUrl: BuildUrlFn;
+    buildUrl: BuildUrlFn;
-  connect: MethodFn;
+    connect: MethodFn;
-  delete: MethodFn;
+    delete: MethodFn;
-  get: MethodFn;
+    get: MethodFn;
-  getConfig: () => Config;
+    getConfig: () => Config;
-  head: MethodFn;
+    head: MethodFn;
-  options: MethodFn;
+    options: MethodFn;
-  patch: MethodFn;
+    patch: MethodFn;
-  post: MethodFn;
+    post: MethodFn;
-  put: MethodFn;
+    put: MethodFn;
-  request: RequestFn;
+    request: RequestFn;
-  setConfig: (config: Config) => Config;
+    setConfig: (config: Config) => Config;
-  trace: MethodFn;
+    trace: MethodFn;
 }
 
 export interface Config {
-  /**
+    /**
-   * Auth token or a function returning auth token. The resolved value will be
+     * Auth token or a function returning auth token. The resolved value will be
-   * added to the request payload as defined by its `security` array.
+     * added to the request payload as defined by its `security` array.
-   */
+     */
-  auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
-  /**
+    /**
-   * A function for serializing request body parameter. By default,
+     * A function for serializing request body parameter. By default,
-   * {@link JSON.stringify()} will be used.
+     * {@link JSON.stringify()} will be used.
-   */
+     */
-  bodySerializer?: BodySerializer | null;
+    bodySerializer?: BodySerializer | null;
-  /**
+    /**
-   * An object containing any HTTP headers that you want to pre-populate your
+     * An object containing any HTTP headers that you want to pre-populate your
-   * `Headers` object with.
+     * `Headers` object with.
-   *
+     *
-   * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
-   */
+     */
-  headers?:
+    headers?:
-    | RequestInit['headers']
+        | RequestInit["headers"]
-    | Record<
+        | Record<
-        string,
+              string,
-        | string
+              | string
-        | number
+              | number
-        | boolean
+              | boolean
-        | (string | number | boolean)[]
+              | (string | number | boolean)[]
-        | null
+              | null
-        | undefined
+              | undefined
-        | unknown
+              | unknown
-      >;
+          >;
-  /**
+    /**
-   * The request method.
+     * The request method.
-   *
+     *
-   * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
-   */
+     */
-  method?:
+    method?:
-    | 'CONNECT'
+        | "CONNECT"
-    | 'DELETE'
+        | "DELETE"
-    | 'GET'
+        | "GET"
-    | 'HEAD'
+        | "HEAD"
-    | 'OPTIONS'
+        | "OPTIONS"
-    | 'PATCH'
+        | "PATCH"
-    | 'POST'
+        | "POST"
-    | 'PUT'
+        | "PUT"
-    | 'TRACE';
+        | "TRACE";
-  /**
+    /**
-   * A function for serializing request query parameters. By default, arrays
+     * A function for serializing request query parameters. By default, arrays
-   * will be exploded in form style, objects will be exploded in deepObject
+     * will be exploded in form style, objects will be exploded in deepObject
-   * style, and reserved characters are percent-encoded.
+     * style, and reserved characters are percent-encoded.
-   *
+     *
-   * This method will have no effect if the native `paramsSerializer()` Axios
+     * This method will have no effect if the native `paramsSerializer()` Axios
-   * API function is used.
+     * API function is used.
-   *
+     *
-   * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
-   */
+     */
-  querySerializer?: QuerySerializer | QuerySerializerOptions;
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
-  /**
+    /**
-   * A function validating request data. This is useful if you want to ensure
+     * A function validating request data. This is useful if you want to ensure
-   * the request conforms to the desired shape, so it can be safely sent to
+     * the request conforms to the desired shape, so it can be safely sent to
-   * the server.
+     * the server.
-   */
+     */
-  requestValidator?: (data: unknown) => Promise<unknown>;
+    requestValidator?: (data: unknown) => Promise<unknown>;
-  /**
+    /**
-   * A function transforming response data before it's returned. This is useful
+     * A function transforming response data before it's returned. This is useful
-   * for post-processing data, e.g. converting ISO strings into Date objects.
+     * for post-processing data, e.g. converting ISO strings into Date objects.
-   */
+     */
-  responseTransformer?: (data: unknown) => Promise<unknown>;
+    responseTransformer?: (data: unknown) => Promise<unknown>;
-  /**
+    /**
-   * A function validating response data. This is useful if you want to ensure
+     * A function validating response data. This is useful if you want to ensure
-   * the response conforms to the desired shape, so it can be safely passed to
+     * the response conforms to the desired shape, so it can be safely passed to
-   * the transformers and returned to the user.
+     * the transformers and returned to the user.
-   */
+     */
-  responseValidator?: (data: unknown) => Promise<unknown>;
+    responseValidator?: (data: unknown) => Promise<unknown>;
 }
 
 type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
-  ? true
+    ? true
-  : [T] extends [never | undefined]
+    : [T] extends [never | undefined]
-    ? [undefined] extends [T]
+      ? [undefined] extends [T]
-      ? false
+          ? false
-      : true
+          : true
-    : false;
+      : false;
 
 export type OmitNever<T extends Record<string, unknown>> = {
-  [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true
+    [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true
-    ? never
+        ? never
-    : K]: T[K];
+        : K]: T[K];
 };

src/lib/client/index.ts

@@ -1,3 +1,3 @@
 // This file is auto-generated by @hey-api/openapi-ts
-export * from './types.gen';
+export * from "./types.gen";
-export * from './sdk.gen';
+export * from "./sdk.gen";

src/lib/client/sdk.gen.ts

@@ -1,11 +1,85 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
-import type { Options as ClientOptions, TDataShape, Client } from './client';
+import type { Client, Options as ClientOptions, TDataShape } from "./client";
-import type { GetBoardsData, GetBoardsResponses, GetBoardsErrors, CreateBoardData, CreateBoardResponses, CreateBoardErrors, DeleteBoardData, DeleteBoardResponses, DeleteBoardErrors, UpdateBoardData, UpdateBoardResponses, UpdateBoardErrors, GetDealsData, GetDealsResponses, GetDealsErrors, UpdateDealData, UpdateDealResponses, UpdateDealErrors, GetProjectsData, GetProjectsResponses, GetStatusesData, GetStatusesResponses, GetStatusesErrors, CreateStatusData, CreateStatusResponses, CreateStatusErrors, DeleteStatusData, DeleteStatusResponses, DeleteStatusErrors, UpdateStatusData, UpdateStatusResponses, UpdateStatusErrors } from './types.gen';
+import { client as _heyApiClient } from "./client.gen";
-import { zGetBoardsData, zGetBoardsResponse2, zCreateBoardData, zCreateBoardResponse2, zDeleteBoardData, zDeleteBoardResponse2, zUpdateBoardData, zUpdateBoardResponse2, zGetDealsData, zGetDealsResponse2, zUpdateDealData, zUpdateDealResponse2, zGetProjectsData, zGetProjectsResponse2, zGetStatusesData, zGetStatusesResponse2, zCreateStatusData, zCreateStatusResponse2, zDeleteStatusData, zDeleteStatusResponse2, zUpdateStatusData, zUpdateStatusResponse2 } from './zod.gen';
+import type {
-import { client as _heyApiClient } from './client.gen';
+    CreateBoardData,
+    CreateBoardErrors,
+    CreateBoardResponses,
+    CreateProjectData,
+    CreateProjectErrors,
+    CreateProjectResponses,
+    CreateStatusData,
+    CreateStatusErrors,
+    CreateStatusResponses,
+    DeleteBoardData,
+    DeleteBoardErrors,
+    DeleteBoardResponses,
+    DeleteProjectData,
+    DeleteProjectErrors,
+    DeleteProjectResponses,
+    DeleteStatusData,
+    DeleteStatusErrors,
+    DeleteStatusResponses,
+    GetBoardsData,
+    GetBoardsErrors,
+    GetBoardsResponses,
+    GetDealsData,
+    GetDealsErrors,
+    GetDealsResponses,
+    GetProjectsData,
+    GetProjectsResponses,
+    GetStatusesData,
+    GetStatusesErrors,
+    GetStatusesResponses,
+    UpdateBoardData,
+    UpdateBoardErrors,
+    UpdateBoardResponses,
+    UpdateDealData,
+    UpdateDealErrors,
+    UpdateDealResponses,
+    UpdateProjectData,
+    UpdateProjectErrors,
+    UpdateProjectResponses,
+    UpdateStatusData,
+    UpdateStatusErrors,
+    UpdateStatusResponses,
+} from "./types.gen";
+import {
+    zCreateBoardData,
+    zCreateBoardResponse2,
+    zCreateProjectData,
+    zCreateProjectResponse2,
+    zCreateStatusData,
+    zCreateStatusResponse2,
+    zDeleteBoardData,
+    zDeleteBoardResponse2,
+    zDeleteProjectData,
+    zDeleteProjectResponse2,
+    zDeleteStatusData,
+    zDeleteStatusResponse2,
+    zGetBoardsData,
+    zGetBoardsResponse2,
+    zGetDealsData,
+    zGetDealsResponse2,
+    zGetProjectsData,
+    zGetProjectsResponse2,
+    zGetStatusesData,
+    zGetStatusesResponse2,
+    zUpdateBoardData,
+    zUpdateBoardResponse2,
+    zUpdateDealData,
+    zUpdateDealResponse2,
+    zUpdateProjectData,
+    zUpdateProjectResponse2,
+    zUpdateStatusData,
+    zUpdateStatusResponse2,
+} from "./zod.gen";
 
-export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = ClientOptions<TData, ThrowOnError> & {
+export type Options<
+    TData extends TDataShape = TDataShape,
+    ThrowOnError extends boolean = boolean,
+> = ClientOptions<TData, ThrowOnError> & {
     /**
      * You can provide a client instance returned by `createClient()` instead of
      * individual options. This might be also useful if you want to implement a
@@ -22,206 +96,349 @@ export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends
 /**
  * Get Boards
  */
-export const getBoards = <ThrowOnError extends boolean = false>(options: Options<GetBoardsData, ThrowOnError>) => {
+export const getBoards = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).get<GetBoardsResponses, GetBoardsErrors, ThrowOnError>({
+    options: Options<GetBoardsData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).get<
+        GetBoardsResponses,
+        GetBoardsErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zGetBoardsData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zGetBoardsResponse2.parseAsync(data);
         },
-        url: '/board/{projectId}',
+        url: "/board/{projectId}",
-        ...options
+        ...options,
     });
 };
 
 /**
  * Create Board
  */
-export const createBoard = <ThrowOnError extends boolean = false>(options: Options<CreateBoardData, ThrowOnError>) => {
+export const createBoard = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).post<CreateBoardResponses, CreateBoardErrors, ThrowOnError>({
+    options: Options<CreateBoardData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).post<
+        CreateBoardResponses,
+        CreateBoardErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zCreateBoardData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zCreateBoardResponse2.parseAsync(data);
         },
-        url: '/board/',
+        url: "/board/",
         ...options,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
-            ...options.headers
+            ...options.headers,
-        }
+        },
     });
 };
 
 /**
  * Delete Board
  */
-export const deleteBoard = <ThrowOnError extends boolean = false>(options: Options<DeleteBoardData, ThrowOnError>) => {
+export const deleteBoard = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).delete<DeleteBoardResponses, DeleteBoardErrors, ThrowOnError>({
+    options: Options<DeleteBoardData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).delete<
+        DeleteBoardResponses,
+        DeleteBoardErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zDeleteBoardData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zDeleteBoardResponse2.parseAsync(data);
         },
-        url: '/board/{boardId}',
+        url: "/board/{boardId}",
-        ...options
+        ...options,
     });
 };
 
 /**
  * Update Board
  */
-export const updateBoard = <ThrowOnError extends boolean = false>(options: Options<UpdateBoardData, ThrowOnError>) => {
+export const updateBoard = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).patch<UpdateBoardResponses, UpdateBoardErrors, ThrowOnError>({
+    options: Options<UpdateBoardData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).patch<
+        UpdateBoardResponses,
+        UpdateBoardErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zUpdateBoardData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zUpdateBoardResponse2.parseAsync(data);
         },
-        url: '/board/{boardId}',
+        url: "/board/{boardId}",
         ...options,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
-            ...options.headers
+            ...options.headers,
-        }
+        },
     });
 };
 
 /**
  * Get Deals
  */
-export const getDeals = <ThrowOnError extends boolean = false>(options: Options<GetDealsData, ThrowOnError>) => {
+export const getDeals = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).get<GetDealsResponses, GetDealsErrors, ThrowOnError>({
+    options: Options<GetDealsData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).get<
+        GetDealsResponses,
+        GetDealsErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zGetDealsData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zGetDealsResponse2.parseAsync(data);
         },
-        url: '/deal/{boardId}',
+        url: "/deal/{boardId}",
-        ...options
+        ...options,
     });
 };
 
 /**
  * Update Deal
  */
-export const updateDeal = <ThrowOnError extends boolean = false>(options: Options<UpdateDealData, ThrowOnError>) => {
+export const updateDeal = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).patch<UpdateDealResponses, UpdateDealErrors, ThrowOnError>({
+    options: Options<UpdateDealData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).patch<
+        UpdateDealResponses,
+        UpdateDealErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zUpdateDealData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zUpdateDealResponse2.parseAsync(data);
         },
-        url: '/deal/{dealId}',
+        url: "/deal/{dealId}",
         ...options,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
-            ...options.headers
+            ...options.headers,
-        }
+        },
     });
 };
 
 /**
  * Get Projects
  */
-export const getProjects = <ThrowOnError extends boolean = false>(options?: Options<GetProjectsData, ThrowOnError>) => {
+export const getProjects = <ThrowOnError extends boolean = false>(
-    return (options?.client ?? _heyApiClient).get<GetProjectsResponses, unknown, ThrowOnError>({
+    options?: Options<GetProjectsData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options?.client ?? _heyApiClient).get<
+        GetProjectsResponses,
+        unknown,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zGetProjectsData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zGetProjectsResponse2.parseAsync(data);
         },
-        url: '/project/',
+        url: "/project/",
-        ...options
+        ...options,
+    });
+};
+
+/**
+ * Create Project
+ */
+export const createProject = <ThrowOnError extends boolean = false>(
+    options: Options<CreateProjectData, ThrowOnError>
+) => {
+    return (options.client ?? _heyApiClient).post<
+        CreateProjectResponses,
+        CreateProjectErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
+            return await zCreateProjectData.parseAsync(data);
+        },
+        responseType: "json",
+        responseValidator: async data => {
+            return await zCreateProjectResponse2.parseAsync(data);
+        },
+        url: "/project/",
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+};
+
+/**
+ * Delete Project
+ */
+export const deleteProject = <ThrowOnError extends boolean = false>(
+    options: Options<DeleteProjectData, ThrowOnError>
+) => {
+    return (options.client ?? _heyApiClient).delete<
+        DeleteProjectResponses,
+        DeleteProjectErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
+            return await zDeleteProjectData.parseAsync(data);
+        },
+        responseType: "json",
+        responseValidator: async data => {
+            return await zDeleteProjectResponse2.parseAsync(data);
+        },
+        url: "/project/{projectId}",
+        ...options,
+    });
+};
+
+/**
+ * Update Project
+ */
+export const updateProject = <ThrowOnError extends boolean = false>(
+    options: Options<UpdateProjectData, ThrowOnError>
+) => {
+    return (options.client ?? _heyApiClient).patch<
+        UpdateProjectResponses,
+        UpdateProjectErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
+            return await zUpdateProjectData.parseAsync(data);
+        },
+        responseType: "json",
+        responseValidator: async data => {
+            return await zUpdateProjectResponse2.parseAsync(data);
+        },
+        url: "/project/{projectId}",
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
     });
 };
 
 /**
  * Get Statuses
  */
-export const getStatuses = <ThrowOnError extends boolean = false>(options: Options<GetStatusesData, ThrowOnError>) => {
+export const getStatuses = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).get<GetStatusesResponses, GetStatusesErrors, ThrowOnError>({
+    options: Options<GetStatusesData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).get<
+        GetStatusesResponses,
+        GetStatusesErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zGetStatusesData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zGetStatusesResponse2.parseAsync(data);
         },
-        url: '/status/{boardId}',
+        url: "/status/{boardId}",
-        ...options
+        ...options,
     });
 };
 
 /**
  * Create Status
  */
-export const createStatus = <ThrowOnError extends boolean = false>(options: Options<CreateStatusData, ThrowOnError>) => {
+export const createStatus = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).post<CreateStatusResponses, CreateStatusErrors, ThrowOnError>({
+    options: Options<CreateStatusData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).post<
+        CreateStatusResponses,
+        CreateStatusErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zCreateStatusData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zCreateStatusResponse2.parseAsync(data);
         },
-        url: '/status/',
+        url: "/status/",
         ...options,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
-            ...options.headers
+            ...options.headers,
-        }
+        },
     });
 };
 
 /**
  * Delete Status
  */
-export const deleteStatus = <ThrowOnError extends boolean = false>(options: Options<DeleteStatusData, ThrowOnError>) => {
+export const deleteStatus = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).delete<DeleteStatusResponses, DeleteStatusErrors, ThrowOnError>({
+    options: Options<DeleteStatusData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).delete<
+        DeleteStatusResponses,
+        DeleteStatusErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zDeleteStatusData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zDeleteStatusResponse2.parseAsync(data);
         },
-        url: '/status/{statusId}',
+        url: "/status/{statusId}",
-        ...options
+        ...options,
     });
 };
 
 /**
  * Update Status
  */
-export const updateStatus = <ThrowOnError extends boolean = false>(options: Options<UpdateStatusData, ThrowOnError>) => {
+export const updateStatus = <ThrowOnError extends boolean = false>(
-    return (options.client ?? _heyApiClient).patch<UpdateStatusResponses, UpdateStatusErrors, ThrowOnError>({
+    options: Options<UpdateStatusData, ThrowOnError>
-        requestValidator: async (data) => {
+) => {
+    return (options.client ?? _heyApiClient).patch<
+        UpdateStatusResponses,
+        UpdateStatusErrors,
+        ThrowOnError
+    >({
+        requestValidator: async data => {
             return await zUpdateStatusData.parseAsync(data);
         },
-        responseType: 'json',
+        responseType: "json",
-        responseValidator: async (data) => {
+        responseValidator: async data => {
             return await zUpdateStatusResponse2.parseAsync(data);
         },
-        url: '/status/{statusId}',
+        url: "/status/{statusId}",
         ...options,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
-            ...options.headers
+            ...options.headers,
-        }
+        },
     });
 };

src/lib/client/types.gen.ts

@@ -54,6 +54,34 @@ export type CreateBoardSchema = {
     lexorank: string;
 };
 
+/**
+ * CreateProjectRequest
+ */
+export type CreateProjectRequest = {
+    project: CreateProjectSchema;
+};
+
+/**
+ * CreateProjectResponse
+ */
+export type CreateProjectResponse = {
+    /**
+     * Message
+     */
+    message: string;
+    project: ProjectSchema;
+};
+
+/**
+ * CreateProjectSchema
+ */
+export type CreateProjectSchema = {
+    /**
+     * Name
+     */
+    name: string;
+};
+
 /**
  * CreateStatusRequest
  */
@@ -122,6 +150,16 @@ export type DeleteBoardResponse = {
     message: string;
 };
 
+/**
+ * DeleteProjectResponse
+ */
+export type DeleteProjectResponse = {
+    /**
+     * Message
+     */
+    message: string;
+};
+
 /**
  * DeleteStatusResponse
  */
@@ -186,14 +224,14 @@ export type HttpValidationError = {
  * ProjectSchema
  */
 export type ProjectSchema = {
-    /**
-     * Name
-     */
-    name: string;
     /**
      * Id
      */
     id: number;
+    /**
+     * Name
+     */
+    name: string;
 };
 
 /**
@@ -280,6 +318,33 @@ export type UpdateDealSchema = {
     statusId?: number | null;
 };
 
+/**
+ * UpdateProjectRequest
+ */
+export type UpdateProjectRequest = {
+    project: UpdateProjectSchema;
+};
+
+/**
+ * UpdateProjectResponse
+ */
+export type UpdateProjectResponse = {
+    /**
+     * Message
+     */
+    message: string;
+};
+
+/**
+ * UpdateProjectSchema
+ */
+export type UpdateProjectSchema = {
+    /**
+     * Name
+     */
+    name?: string | null;
+};
+
 /**
  * UpdateStatusRequest
  */
@@ -338,7 +403,7 @@ export type GetBoardsData = {
         projectId: number;
     };
     query?: never;
-    url: '/board/{projectId}';
+    url: "/board/{projectId}";
 };
 
 export type GetBoardsErrors = {
@@ -363,7 +428,7 @@ export type CreateBoardData = {
     body: CreateBoardRequest;
     path?: never;
     query?: never;
-    url: '/board/';
+    url: "/board/";
 };
 
 export type CreateBoardErrors = {
@@ -382,7 +447,8 @@ export type CreateBoardResponses = {
     200: CreateBoardResponse;
 };
 
-export type CreateBoardResponse2 = CreateBoardResponses[keyof CreateBoardResponses];
+export type CreateBoardResponse2 =
+    CreateBoardResponses[keyof CreateBoardResponses];
 
 export type DeleteBoardData = {
     body?: never;
@@ -393,7 +459,7 @@ export type DeleteBoardData = {
         boardId: number;
     };
     query?: never;
-    url: '/board/{boardId}';
+    url: "/board/{boardId}";
 };
 
 export type DeleteBoardErrors = {
@@ -412,7 +478,8 @@ export type DeleteBoardResponses = {
     200: DeleteBoardResponse;
 };
 
-export type DeleteBoardResponse2 = DeleteBoardResponses[keyof DeleteBoardResponses];
+export type DeleteBoardResponse2 =
+    DeleteBoardResponses[keyof DeleteBoardResponses];
 
 export type UpdateBoardData = {
     body: UpdateBoardRequest;
@@ -423,7 +490,7 @@ export type UpdateBoardData = {
         boardId: number;
     };
     query?: never;
-    url: '/board/{boardId}';
+    url: "/board/{boardId}";
 };
 
 export type UpdateBoardErrors = {
@@ -442,7 +509,8 @@ export type UpdateBoardResponses = {
     200: UpdateBoardResponse;
 };
 
-export type UpdateBoardResponse2 = UpdateBoardResponses[keyof UpdateBoardResponses];
+export type UpdateBoardResponse2 =
+    UpdateBoardResponses[keyof UpdateBoardResponses];
 
 export type GetDealsData = {
     body?: never;
@@ -453,7 +521,7 @@ export type GetDealsData = {
         boardId: number;
     };
     query?: never;
-    url: '/deal/{boardId}';
+    url: "/deal/{boardId}";
 };
 
 export type GetDealsErrors = {
@@ -483,7 +551,7 @@ export type UpdateDealData = {
         dealId: number;
     };
     query?: never;
-    url: '/deal/{dealId}';
+    url: "/deal/{dealId}";
 };
 
 export type UpdateDealErrors = {
@@ -502,13 +570,14 @@ export type UpdateDealResponses = {
     200: UpdateDealResponse;
 };
 
-export type UpdateDealResponse2 = UpdateDealResponses[keyof UpdateDealResponses];
+export type UpdateDealResponse2 =
+    UpdateDealResponses[keyof UpdateDealResponses];
 
 export type GetProjectsData = {
     body?: never;
     path?: never;
     query?: never;
-    url: '/project/';
+    url: "/project/";
 };
 
 export type GetProjectsResponses = {
@@ -518,7 +587,96 @@ export type GetProjectsResponses = {
     200: GetProjectsResponse;
 };
 
-export type GetProjectsResponse2 = GetProjectsResponses[keyof GetProjectsResponses];
+export type GetProjectsResponse2 =
+    GetProjectsResponses[keyof GetProjectsResponses];
+
+export type CreateProjectData = {
+    body: CreateProjectRequest;
+    path?: never;
+    query?: never;
+    url: "/project/";
+};
+
+export type CreateProjectErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type CreateProjectError = CreateProjectErrors[keyof CreateProjectErrors];
+
+export type CreateProjectResponses = {
+    /**
+     * Successful Response
+     */
+    200: CreateProjectResponse;
+};
+
+export type CreateProjectResponse2 =
+    CreateProjectResponses[keyof CreateProjectResponses];
+
+export type DeleteProjectData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Projectid
+         */
+        projectId: number;
+    };
+    url: "/project/{projectId}";
+};
+
+export type DeleteProjectErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type DeleteProjectError = DeleteProjectErrors[keyof DeleteProjectErrors];
+
+export type DeleteProjectResponses = {
+    /**
+     * Successful Response
+     */
+    200: DeleteProjectResponse;
+};
+
+export type DeleteProjectResponse2 =
+    DeleteProjectResponses[keyof DeleteProjectResponses];
+
+export type UpdateProjectData = {
+    body: UpdateProjectRequest;
+    path?: never;
+    query: {
+        /**
+         * Projectid
+         */
+        projectId: number;
+    };
+    url: "/project/{projectId}";
+};
+
+export type UpdateProjectErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type UpdateProjectError = UpdateProjectErrors[keyof UpdateProjectErrors];
+
+export type UpdateProjectResponses = {
+    /**
+     * Successful Response
+     */
+    200: UpdateProjectResponse;
+};
+
+export type UpdateProjectResponse2 =
+    UpdateProjectResponses[keyof UpdateProjectResponses];
 
 export type GetStatusesData = {
     body?: never;
@@ -529,7 +687,7 @@ export type GetStatusesData = {
         boardId: number;
     };
     query?: never;
-    url: '/status/{boardId}';
+    url: "/status/{boardId}";
 };
 
 export type GetStatusesErrors = {
@@ -548,13 +706,14 @@ export type GetStatusesResponses = {
     200: GetStatusesResponse;
 };
 
-export type GetStatusesResponse2 = GetStatusesResponses[keyof GetStatusesResponses];
+export type GetStatusesResponse2 =
+    GetStatusesResponses[keyof GetStatusesResponses];
 
 export type CreateStatusData = {
     body: CreateStatusRequest;
     path?: never;
     query?: never;
-    url: '/status/';
+    url: "/status/";
 };
 
 export type CreateStatusErrors = {
@@ -573,7 +732,8 @@ export type CreateStatusResponses = {
     200: CreateStatusResponse;
 };
 
-export type CreateStatusResponse2 = CreateStatusResponses[keyof CreateStatusResponses];
+export type CreateStatusResponse2 =
+    CreateStatusResponses[keyof CreateStatusResponses];
 
 export type DeleteStatusData = {
     body?: never;
@@ -584,7 +744,7 @@ export type DeleteStatusData = {
         statusId: number;
     };
     query?: never;
-    url: '/status/{statusId}';
+    url: "/status/{statusId}";
 };
 
 export type DeleteStatusErrors = {
@@ -603,7 +763,8 @@ export type DeleteStatusResponses = {
     200: DeleteStatusResponse;
 };
 
-export type DeleteStatusResponse2 = DeleteStatusResponses[keyof DeleteStatusResponses];
+export type DeleteStatusResponse2 =
+    DeleteStatusResponses[keyof DeleteStatusResponses];
 
 export type UpdateStatusData = {
     body: UpdateStatusRequest;
@@ -614,7 +775,7 @@ export type UpdateStatusData = {
         statusId: number;
     };
     query?: never;
-    url: '/status/{statusId}';
+    url: "/status/{statusId}";
 };
 
 export type UpdateStatusErrors = {
@@ -633,7 +794,8 @@ export type UpdateStatusResponses = {
     200: UpdateStatusResponse;
 };
 
-export type UpdateStatusResponse2 = UpdateStatusResponses[keyof UpdateStatusResponses];
+export type UpdateStatusResponse2 =
+    UpdateStatusResponses[keyof UpdateStatusResponses];
 
 export type ClientOptions = {
     baseURL: `${string}://${string}/api` | (string & {});

src/lib/client/zod.gen.ts

@@ -1,6 +1,6 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
-import { z } from 'zod';
+import { z } from "zod";
 
 /**
  * BoardSchema
@@ -8,7 +8,7 @@ import { z } from 'zod';
 export const zBoardSchema = z.object({
     id: z.int(),
     name: z.string(),
-    lexorank: z.string()
+    lexorank: z.string(),
 });
 
 /**
@@ -17,14 +17,14 @@ export const zBoardSchema = z.object({
 export const zCreateBoardSchema = z.object({
     name: z.string(),
     projectId: z.int(),
-    lexorank: z.string()
+    lexorank: z.string(),
 });
 
 /**
  * CreateBoardRequest
  */
 export const zCreateBoardRequest = z.object({
-    board: zCreateBoardSchema
+    board: zCreateBoardSchema,
 });
 
 /**
@@ -32,7 +32,37 @@ export const zCreateBoardRequest = z.object({
  */
 export const zCreateBoardResponse = z.object({
     message: z.string(),
-    board: zBoardSchema
+    board: zBoardSchema,
+});
+
+/**
+ * CreateProjectSchema
+ */
+export const zCreateProjectSchema = z.object({
+    name: z.string(),
+});
+
+/**
+ * CreateProjectRequest
+ */
+export const zCreateProjectRequest = z.object({
+    project: zCreateProjectSchema,
+});
+
+/**
+ * ProjectSchema
+ */
+export const zProjectSchema = z.object({
+    id: z.int(),
+    name: z.string(),
+});
+
+/**
+ * CreateProjectResponse
+ */
+export const zCreateProjectResponse = z.object({
+    message: z.string(),
+    project: zProjectSchema,
 });
 
 /**
@@ -41,14 +71,14 @@ export const zCreateBoardResponse = z.object({
 export const zCreateStatusSchema = z.object({
     name: z.string(),
     boardId: z.int(),
-    lexorank: z.string()
+    lexorank: z.string(),
 });
 
 /**
  * CreateStatusRequest
  */
 export const zCreateStatusRequest = z.object({
-    status: zCreateStatusSchema
+    status: zCreateStatusSchema,
 });
 
 /**
@@ -57,7 +87,7 @@ export const zCreateStatusRequest = z.object({
 export const zStatusSchema = z.object({
     id: z.int(),
     name: z.string(),
-    lexorank: z.string()
+    lexorank: z.string(),
 });
 
 /**
@@ -65,7 +95,7 @@ export const zStatusSchema = z.object({
  */
 export const zCreateStatusResponse = z.object({
     message: z.string(),
-    status: zStatusSchema
+    status: zStatusSchema,
 });
 
 /**
@@ -75,172 +105,168 @@ export const zDealSchema = z.object({
     name: z.string(),
     id: z.int(),
     lexorank: z.string(),
-    statusId: z.int()
+    statusId: z.int(),
 });
 
 /**
  * DeleteBoardResponse
  */
 export const zDeleteBoardResponse = z.object({
-    message: z.string()
+    message: z.string(),
+});
+
+/**
+ * DeleteProjectResponse
+ */
+export const zDeleteProjectResponse = z.object({
+    message: z.string(),
 });
 
 /**
  * DeleteStatusResponse
  */
 export const zDeleteStatusResponse = z.object({
-    message: z.string()
+    message: z.string(),
 });
 
 /**
  * GetBoardsResponse
  */
 export const zGetBoardsResponse = z.object({
-    boards: z.array(zBoardSchema)
+    boards: z.array(zBoardSchema),
 });
 
 /**
  * GetDealsResponse
  */
 export const zGetDealsResponse = z.object({
-    deals: z.array(zDealSchema)
+    deals: z.array(zDealSchema),
-});
-
-/**
- * ProjectSchema
- */
-export const zProjectSchema = z.object({
-    name: z.string(),
-    id: z.int()
 });
 
 /**
  * GetProjectsResponse
  */
 export const zGetProjectsResponse = z.object({
-    projects: z.array(zProjectSchema)
+    projects: z.array(zProjectSchema),
 });
 
 /**
  * GetStatusesResponse
  */
 export const zGetStatusesResponse = z.object({
-    statuses: z.array(zStatusSchema)
+    statuses: z.array(zStatusSchema),
 });
 
 /**
  * ValidationError
  */
 export const zValidationError = z.object({
-    loc: z.array(z.union([
+    loc: z.array(z.union([z.string(), z.int()])),
-        z.string(),
-        z.int()
-    ])),
     msg: z.string(),
-    type: z.string()
+    type: z.string(),
 });
 
 /**
  * HTTPValidationError
  */
 export const zHttpValidationError = z.object({
-    detail: z.optional(z.array(zValidationError))
+    detail: z.optional(z.array(zValidationError)),
 });
 
 /**
  * UpdateBoardSchema
  */
 export const zUpdateBoardSchema = z.object({
-    name: z.optional(z.union([
+    name: z.optional(z.union([z.string(), z.null()])),
-        z.string(),
+    lexorank: z.optional(z.union([z.string(), z.null()])),
-        z.null()
-    ])),
-    lexorank: z.optional(z.union([
-        z.string(),
-        z.null()
-    ]))
 });
 
 /**
  * UpdateBoardRequest
  */
 export const zUpdateBoardRequest = z.object({
-    board: zUpdateBoardSchema
+    board: zUpdateBoardSchema,
 });
 
 /**
  * UpdateBoardResponse
  */
 export const zUpdateBoardResponse = z.object({
-    message: z.string()
+    message: z.string(),
 });
 
 /**
  * UpdateDealSchema
  */
 export const zUpdateDealSchema = z.object({
-    name: z.optional(z.union([
+    name: z.optional(z.union([z.string(), z.null()])),
-        z.string(),
+    lexorank: z.optional(z.union([z.string(), z.null()])),
-        z.null()
+    statusId: z.optional(z.union([z.int(), z.null()])),
-    ])),
-    lexorank: z.optional(z.union([
-        z.string(),
-        z.null()
-    ])),
-    statusId: z.optional(z.union([
-        z.int(),
-        z.null()
-    ]))
 });
 
 /**
  * UpdateDealRequest
  */
 export const zUpdateDealRequest = z.object({
-    deal: zUpdateDealSchema
+    deal: zUpdateDealSchema,
 });
 
 /**
  * UpdateDealResponse
  */
 export const zUpdateDealResponse = z.object({
-    message: z.string()
+    message: z.string(),
+});
+
+/**
+ * UpdateProjectSchema
+ */
+export const zUpdateProjectSchema = z.object({
+    name: z.optional(z.union([z.string(), z.null()])),
+});
+
+/**
+ * UpdateProjectRequest
+ */
+export const zUpdateProjectRequest = z.object({
+    project: zUpdateProjectSchema,
+});
+
+/**
+ * UpdateProjectResponse
+ */
+export const zUpdateProjectResponse = z.object({
+    message: z.string(),
 });
 
 /**
  * UpdateStatusSchema
  */
 export const zUpdateStatusSchema = z.object({
-    name: z.optional(z.union([
+    name: z.optional(z.union([z.string(), z.null()])),
-        z.string(),
+    lexorank: z.optional(z.union([z.string(), z.null()])),
-        z.null()
-    ])),
-    lexorank: z.optional(z.union([
-        z.string(),
-        z.null()
-    ]))
 });
 
 /**
  * UpdateStatusRequest
  */
 export const zUpdateStatusRequest = z.object({
-    status: zUpdateStatusSchema
+    status: zUpdateStatusSchema,
 });
 
 /**
  * UpdateStatusResponse
  */
 export const zUpdateStatusResponse = z.object({
-    message: z.string()
+    message: z.string(),
 });
 
 export const zGetBoardsData = z.object({
     body: z.optional(z.never()),
     path: z.object({
-        projectId: z.int()
+        projectId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -251,7 +277,7 @@ export const zGetBoardsResponse2 = zGetBoardsResponse;
 export const zCreateBoardData = z.object({
     body: zCreateBoardRequest,
     path: z.optional(z.never()),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -262,9 +288,9 @@ export const zCreateBoardResponse2 = zCreateBoardResponse;
 export const zDeleteBoardData = z.object({
     body: z.optional(z.never()),
     path: z.object({
-        boardId: z.int()
+        boardId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -275,9 +301,9 @@ export const zDeleteBoardResponse2 = zDeleteBoardResponse;
 export const zUpdateBoardData = z.object({
     body: zUpdateBoardRequest,
     path: z.object({
-        boardId: z.int()
+        boardId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -288,9 +314,9 @@ export const zUpdateBoardResponse2 = zUpdateBoardResponse;
 export const zGetDealsData = z.object({
     body: z.optional(z.never()),
     path: z.object({
-        boardId: z.int()
+        boardId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -301,9 +327,9 @@ export const zGetDealsResponse2 = zGetDealsResponse;
 export const zUpdateDealData = z.object({
     body: zUpdateDealRequest,
     path: z.object({
-        dealId: z.int()
+        dealId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -314,7 +340,7 @@ export const zUpdateDealResponse2 = zUpdateDealResponse;
 export const zGetProjectsData = z.object({
     body: z.optional(z.never()),
     path: z.optional(z.never()),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -322,12 +348,49 @@ export const zGetProjectsData = z.object({
  */
 export const zGetProjectsResponse2 = zGetProjectsResponse;
 
+export const zCreateProjectData = z.object({
+    body: zCreateProjectRequest,
+    path: z.optional(z.never()),
+    query: z.optional(z.never()),
+});
+
+/**
+ * Successful Response
+ */
+export const zCreateProjectResponse2 = zCreateProjectResponse;
+
+export const zDeleteProjectData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.object({
+        projectId: z.int(),
+    }),
+});
+
+/**
+ * Successful Response
+ */
+export const zDeleteProjectResponse2 = zDeleteProjectResponse;
+
+export const zUpdateProjectData = z.object({
+    body: zUpdateProjectRequest,
+    path: z.optional(z.never()),
+    query: z.object({
+        projectId: z.int(),
+    }),
+});
+
+/**
+ * Successful Response
+ */
+export const zUpdateProjectResponse2 = zUpdateProjectResponse;
+
 export const zGetStatusesData = z.object({
     body: z.optional(z.never()),
     path: z.object({
-        boardId: z.int()
+        boardId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -338,7 +401,7 @@ export const zGetStatusesResponse2 = zGetStatusesResponse;
 export const zCreateStatusData = z.object({
     body: zCreateStatusRequest,
     path: z.optional(z.never()),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -349,9 +412,9 @@ export const zCreateStatusResponse2 = zCreateStatusResponse;
 export const zDeleteStatusData = z.object({
     body: z.optional(z.never()),
     path: z.object({
-        statusId: z.int()
+        statusId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**
@@ -362,9 +425,9 @@ export const zDeleteStatusResponse2 = zDeleteStatusResponse;
 export const zUpdateStatusData = z.object({
     body: zUpdateStatusRequest,
     path: z.object({
-        statusId: z.int()
+        statusId: z.int(),
     }),
-    query: z.optional(z.never())
+    query: z.optional(z.never()),
 });
 
 /**