refactor(ui): regenerate orval client against the v2 axum router

ui/lib/api/blobs/blobs.ts

@@ -1,127 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useQuery } from '@tanstack/react-query'
-import type {
-  DataTag,
-  DefinedInitialDataOptions,
-  DefinedUseQueryResult,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  UndefinedInitialDataOptions,
-  UseQueryOptions,
-  UseQueryResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type { ApiError } from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getGetBlobUrl = (hash: string) => {
-  return `/api/v1/blobs/${hash}`
-}
-
-export const getBlob = async (hash: string, options?: RequestInit): Promise<Blob> => {
-  return fetchApi<Blob>(getGetBlobUrl(hash), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getGetBlobQueryKey = (hash: string) => {
-  return [`/api/v1/blobs/${hash}`] as const
-}
-
-export const getGetBlobQueryOptions = <
-  TData = Awaited<ReturnType<typeof getBlob>>,
-  TError = ApiError,
->(
-  hash: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getBlob>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getGetBlobQueryKey(hash)
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof getBlob>>> = ({ signal }) =>
-    getBlob(hash, { signal, ...requestOptions })
-
-  return {
-    queryKey,
-    queryFn,
-    enabled: !!hash,
-    gcTime: 300000,
-    retry: 1,
-    ...queryOptions,
-  } as UseQueryOptions<Awaited<ReturnType<typeof getBlob>>, TError, TData> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-}
-
-export type GetBlobQueryResult = NonNullable<Awaited<ReturnType<typeof getBlob>>>
-export type GetBlobQueryError = ApiError
-
-export function useGetBlob<TData = Awaited<ReturnType<typeof getBlob>>, TError = ApiError>(
-  hash: string,
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getBlob>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getBlob>>,
-          TError,
-          Awaited<ReturnType<typeof getBlob>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetBlob<TData = Awaited<ReturnType<typeof getBlob>>, TError = ApiError>(
-  hash: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getBlob>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getBlob>>,
-          TError,
-          Awaited<ReturnType<typeof getBlob>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetBlob<TData = Awaited<ReturnType<typeof getBlob>>, TError = ApiError>(
-  hash: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getBlob>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useGetBlob<TData = Awaited<ReturnType<typeof getBlob>>, TError = ApiError>(
-  hash: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getBlob>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getGetBlobQueryOptions(hash, options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}

ui/lib/api/default/default.msw.ts

@@ -0,0 +1,1940 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import { faker } from '@faker-js/faker'
+import { HttpResponse, delay, http } from 'msw'
+import type { RequestHandlerOptions } from 'msw'
+
+import {
+  FontSource,
+  ImageRole,
+  JobStatus,
+  LlmProviderCatalogStatus,
+  LlmStateStatus,
+  LlmTargetKind,
+  MaskRole,
+  PipelineStep,
+  TextAlign,
+  TextDirection,
+} from '../schemas'
+import type {
+  AddImageLayerResponse,
+  AppConfig,
+  AppEvent,
+  CreatePagesResponse,
+  DataConfig,
+  EngineCatalog,
+  FontFaceInfo,
+  FontPrediction,
+  GoogleFontCatalog,
+  HistoryResult,
+  HttpConfig,
+  ListDownloadsResponse,
+  ListOperationsResponse,
+  ListProjectsResponse,
+  LlmCatalog,
+  LlmState,
+  LlmTarget,
+  MetaInfo,
+  PipelineConfig,
+  ProjectSummary,
+  PutMaskResponse,
+  SceneSnapshot,
+  StartDownloadResponse,
+  StartPipelineResponse,
+  TextShaderEffect,
+  TextStrokeStyle,
+  TextStyle,
+  Transform,
+} from '../schemas'
+
+export const getGetBlobResponseMock = (): ArrayBuffer =>
+  new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))
+
+export const getGetConfigResponseDataConfigMock = (
+  overrideResponse: Partial<DataConfig> = {},
+): DataConfig => ({
+  ...{ path: faker.string.alpha({ length: { min: 10, max: 20 } }) },
+  ...overrideResponse,
+})
+
+export const getGetConfigResponseHttpConfigMock = (
+  overrideResponse: Partial<HttpConfig> = {},
+): HttpConfig => ({
+  ...{
+    connect_timeout: faker.number.int({ min: 0 }),
+    max_retries: faker.number.int({ min: 0 }),
+    read_timeout: faker.number.int({ min: 0 }),
+  },
+  ...overrideResponse,
+})
+
+export const getGetConfigResponsePipelineConfigMock = (
+  overrideResponse: Partial<PipelineConfig> = {},
+): PipelineConfig => ({
+  ...{
+    bubble_segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    detector: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    font_detector: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    inpainter: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    ocr: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    renderer: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    translator: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  },
+  ...overrideResponse,
+})
+
+export const getGetConfigResponseMock = (
+  overrideResponse: Partial<Extract<AppConfig, object>> = {},
+): AppConfig => ({
+  data: faker.helpers.arrayElement([{ ...getGetConfigResponseDataConfigMock() }]),
+  http: faker.helpers.arrayElement([{ ...getGetConfigResponseHttpConfigMock() }]),
+  pipeline: faker.helpers.arrayElement([{ ...getGetConfigResponsePipelineConfigMock() }]),
+  providers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      api_key: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      base_url: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getPatchConfigResponseDataConfigMock = (
+  overrideResponse: Partial<DataConfig> = {},
+): DataConfig => ({
+  ...{ path: faker.string.alpha({ length: { min: 10, max: 20 } }) },
+  ...overrideResponse,
+})
+
+export const getPatchConfigResponseHttpConfigMock = (
+  overrideResponse: Partial<HttpConfig> = {},
+): HttpConfig => ({
+  ...{
+    connect_timeout: faker.number.int({ min: 0 }),
+    max_retries: faker.number.int({ min: 0 }),
+    read_timeout: faker.number.int({ min: 0 }),
+  },
+  ...overrideResponse,
+})
+
+export const getPatchConfigResponsePipelineConfigMock = (
+  overrideResponse: Partial<PipelineConfig> = {},
+): PipelineConfig => ({
+  ...{
+    bubble_segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    detector: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    font_detector: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    inpainter: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    ocr: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    renderer: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    segmenter: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    translator: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  },
+  ...overrideResponse,
+})
+
+export const getPatchConfigResponseMock = (
+  overrideResponse: Partial<Extract<AppConfig, object>> = {},
+): AppConfig => ({
+  data: faker.helpers.arrayElement([{ ...getPatchConfigResponseDataConfigMock() }]),
+  http: faker.helpers.arrayElement([{ ...getPatchConfigResponseHttpConfigMock() }]),
+  pipeline: faker.helpers.arrayElement([{ ...getPatchConfigResponsePipelineConfigMock() }]),
+  providers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      api_key: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      base_url: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getListDownloadsResponseMock = (
+  overrideResponse: Partial<Extract<ListDownloadsResponse, object>> = {},
+): ListDownloadsResponse => ({
+  downloads: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      downloaded: faker.number.int({ min: 0 }),
+      filename: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      status: faker.helpers.arrayElement([
+        { status: faker.helpers.arrayElement(['started'] as const) },
+        { status: faker.helpers.arrayElement(['downloading'] as const) },
+        { status: faker.helpers.arrayElement(['completed'] as const) },
+        {
+          reason: faker.string.alpha({ length: { min: 10, max: 20 } }),
+          status: faker.helpers.arrayElement(['failed'] as const),
+        },
+      ]),
+      total: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]),
+        undefined,
+      ]),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getStartDownloadResponseMock = (
+  overrideResponse: Partial<Extract<StartDownloadResponse, object>> = {},
+): StartDownloadResponse => ({
+  operationId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  ...overrideResponse,
+})
+
+export const getGetEngineCatalogResponseMock = (
+  overrideResponse: Partial<Extract<EngineCatalog, object>> = {},
+): EngineCatalog => ({
+  bubbleSegmenters: Array.from(
+    { length: faker.number.int({ min: 1, max: 10 }) },
+    (_, i) => i + 1,
+  ).map(() => ({
+    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+    ),
+  })),
+  detectors: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+    }),
+  ),
+  fontDetectors: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+    }),
+  ),
+  inpainters: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+    }),
+  ),
+  ocr: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+    ),
+  })),
+  renderers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+    }),
+  ),
+  segmenters: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+    }),
+  ),
+  translators: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      produces: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getEventsResponseLlmTargetMock = (
+  overrideResponse: Partial<LlmTarget> = {},
+): LlmTarget => ({
+  ...{
+    kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)),
+    modelId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    providerId: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+      undefined,
+    ]),
+  },
+  ...overrideResponse,
+})
+
+export const getEventsResponseMock = (): AppEvent =>
+  faker.helpers.arrayElement([
+    {
+      event: faker.helpers.arrayElement(['jobStarted'] as const),
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      kind: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    },
+    {
+      ...{
+        currentPage: faker.number.int({ min: 0 }),
+        currentStepIndex: faker.number.int({ min: 0 }),
+        jobId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        overallPercent: faker.number.int({ min: 0 }),
+        status: faker.helpers.arrayElement([
+          { status: faker.helpers.arrayElement(['running'] as const) },
+          { status: faker.helpers.arrayElement(['completed'] as const) },
+          { status: faker.helpers.arrayElement(['cancelled'] as const) },
+          {
+            reason: faker.string.alpha({ length: { min: 10, max: 20 } }),
+            status: faker.helpers.arrayElement(['failed'] as const),
+          },
+        ]),
+        step: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([
+            null,
+            faker.helpers.arrayElement(Object.values(PipelineStep)),
+          ]),
+          undefined,
+        ]),
+        totalPages: faker.number.int({ min: 0 }),
+        totalSteps: faker.number.int({ min: 0 }),
+      },
+      ...{ event: faker.helpers.arrayElement(['jobProgress'] as const) },
+    },
+    {
+      ...{
+        error: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+          undefined,
+        ]),
+        id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        status: faker.helpers.arrayElement(Object.values(JobStatus)),
+      },
+      ...{ event: faker.helpers.arrayElement(['jobFinished'] as const) },
+    },
+    {
+      ...{
+        downloaded: faker.number.int({ min: 0 }),
+        filename: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        status: faker.helpers.arrayElement([
+          { status: faker.helpers.arrayElement(['started'] as const) },
+          { status: faker.helpers.arrayElement(['downloading'] as const) },
+          { status: faker.helpers.arrayElement(['completed'] as const) },
+          {
+            reason: faker.string.alpha({ length: { min: 10, max: 20 } }),
+            status: faker.helpers.arrayElement(['failed'] as const),
+          },
+        ]),
+        total: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]),
+          undefined,
+        ]),
+      },
+      ...{ event: faker.helpers.arrayElement(['downloadProgress'] as const) },
+    },
+    {
+      event: faker.helpers.arrayElement(['llmLoading'] as const),
+      target: {
+        kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)),
+        modelId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        providerId: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+          undefined,
+        ]),
+      },
+    },
+    {
+      event: faker.helpers.arrayElement(['llmLoaded'] as const),
+      target: {
+        kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)),
+        modelId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        providerId: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+          undefined,
+        ]),
+      },
+    },
+    {
+      event: faker.helpers.arrayElement(['llmFailed'] as const),
+      target: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([null, { ...getEventsResponseLlmTargetMock() }]),
+        undefined,
+      ]),
+    },
+    { event: faker.helpers.arrayElement(['llmUnloaded'] as const) },
+    {
+      ...{
+        downloads: Array.from(
+          { length: faker.number.int({ min: 1, max: 10 }) },
+          (_, i) => i + 1,
+        ).map(() => ({
+          downloaded: faker.number.int({ min: 0 }),
+          filename: faker.string.alpha({ length: { min: 10, max: 20 } }),
+          id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+          status: faker.helpers.arrayElement([
+            { status: faker.helpers.arrayElement(['started'] as const) },
+            { status: faker.helpers.arrayElement(['downloading'] as const) },
+            { status: faker.helpers.arrayElement(['completed'] as const) },
+            {
+              reason: faker.string.alpha({ length: { min: 10, max: 20 } }),
+              status: faker.helpers.arrayElement(['failed'] as const),
+            },
+          ]),
+          total: faker.helpers.arrayElement([
+            faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]),
+            undefined,
+          ]),
+        })),
+        jobs: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+          () => ({
+            error: faker.helpers.arrayElement([
+              faker.helpers.arrayElement([
+                faker.string.alpha({ length: { min: 10, max: 20 } }),
+                null,
+              ]),
+              undefined,
+            ]),
+            id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+            kind: faker.string.alpha({ length: { min: 10, max: 20 } }),
+            status: faker.helpers.arrayElement(Object.values(JobStatus)),
+          }),
+        ),
+      },
+      ...{ event: faker.helpers.arrayElement(['snapshot'] as const) },
+    },
+  ])
+
+export const getListFontsResponseMock = (): FontFaceInfo[] =>
+  Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    cached: faker.datatype.boolean(),
+    category: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+      undefined,
+    ]),
+    familyName: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    postScriptName: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    source: faker.helpers.arrayElement(Object.values(FontSource)),
+  }))
+
+export const getGetGoogleFontsCatalogResponseMock = (
+  overrideResponse: Partial<Extract<GoogleFontCatalog, object>> = {},
+): GoogleFontCatalog => ({
+  fonts: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({
+    category: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    family: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    subsets: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+    ),
+    variants: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        filename: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        style: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        weight: faker.number.int({ min: 0 }),
+      }),
+    ),
+  })),
+  ...overrideResponse,
+})
+
+export const getGetGoogleFontFileResponseMock = (): ArrayBuffer =>
+  new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))
+
+export const getApplyCommandResponseMock = (
+  overrideResponse: Partial<Extract<HistoryResult, object>> = {},
+): HistoryResult => ({
+  epoch: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]),
+    undefined,
+  ]),
+  ...overrideResponse,
+})
+
+export const getRedoResponseMock = (
+  overrideResponse: Partial<Extract<HistoryResult, object>> = {},
+): HistoryResult => ({
+  epoch: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]),
+    undefined,
+  ]),
+  ...overrideResponse,
+})
+
+export const getUndoResponseMock = (
+  overrideResponse: Partial<Extract<HistoryResult, object>> = {},
+): HistoryResult => ({
+  epoch: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.number.int({ min: 0 }), null]),
+    undefined,
+  ]),
+  ...overrideResponse,
+})
+
+export const getGetCatalogResponseMock = (
+  overrideResponse: Partial<Extract<LlmCatalog, object>> = {},
+): LlmCatalog => ({
+  localModels: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      languages: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => faker.string.alpha({ length: { min: 10, max: 20 } }),
+      ),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      target: {
+        kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)),
+        modelId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        providerId: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+          undefined,
+        ]),
+      },
+    }),
+  ),
+  providers: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      baseUrl: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      error: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      hasApiKey: faker.datatype.boolean(),
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      models: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+        () => ({
+          languages: Array.from(
+            { length: faker.number.int({ min: 1, max: 10 }) },
+            (_, i) => i + 1,
+          ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })),
+          name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+          target: {
+            kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)),
+            modelId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+            providerId: faker.helpers.arrayElement([
+              faker.helpers.arrayElement([
+                faker.string.alpha({ length: { min: 10, max: 20 } }),
+                null,
+              ]),
+              undefined,
+            ]),
+          },
+        }),
+      ),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      requiresApiKey: faker.datatype.boolean(),
+      requiresBaseUrl: faker.datatype.boolean(),
+      status: faker.helpers.arrayElement(Object.values(LlmProviderCatalogStatus)),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getGetCurrentLlmResponseLlmTargetMock = (
+  overrideResponse: Partial<LlmTarget> = {},
+): LlmTarget => ({
+  ...{
+    kind: faker.helpers.arrayElement(Object.values(LlmTargetKind)),
+    modelId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+    providerId: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+      undefined,
+    ]),
+  },
+  ...overrideResponse,
+})
+
+export const getGetCurrentLlmResponseMock = (
+  overrideResponse: Partial<Extract<LlmState, object>> = {},
+): LlmState => ({
+  error: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+    undefined,
+  ]),
+  status: faker.helpers.arrayElement(Object.values(LlmStateStatus)),
+  target: faker.helpers.arrayElement([
+    faker.helpers.arrayElement([null, { ...getGetCurrentLlmResponseLlmTargetMock() }]),
+    undefined,
+  ]),
+  ...overrideResponse,
+})
+
+export const getGetMetaResponseMock = (
+  overrideResponse: Partial<Extract<MetaInfo, object>> = {},
+): MetaInfo => ({
+  mlDevice: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  version: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  ...overrideResponse,
+})
+
+export const getListOperationsResponseMock = (
+  overrideResponse: Partial<Extract<ListOperationsResponse, object>> = {},
+): ListOperationsResponse => ({
+  operations: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      error: faker.helpers.arrayElement([
+        faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+        undefined,
+      ]),
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      kind: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      status: faker.helpers.arrayElement(Object.values(JobStatus)),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getCreatePagesResponseMock = (
+  overrideResponse: Partial<Extract<CreatePagesResponse, object>> = {},
+): CreatePagesResponse => ({
+  pages: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+    faker.string.uuid(),
+  ),
+  ...overrideResponse,
+})
+
+export const getCreatePagesFromPathsResponseMock = (
+  overrideResponse: Partial<Extract<CreatePagesResponse, object>> = {},
+): CreatePagesResponse => ({
+  pages: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+    faker.string.uuid(),
+  ),
+  ...overrideResponse,
+})
+
+export const getAddImageLayerResponseMock = (
+  overrideResponse: Partial<Extract<AddImageLayerResponse, object>> = {},
+): AddImageLayerResponse => ({ node: faker.string.uuid(), ...overrideResponse })
+
+export const getPutMaskResponseMock = (
+  overrideResponse: Partial<Extract<PutMaskResponse, object>> = {},
+): PutMaskResponse => ({
+  blob: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  node: faker.string.uuid(),
+  ...overrideResponse,
+})
+
+export const getGetPageThumbnailResponseMock = (): ArrayBuffer =>
+  new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))
+
+export const getStartPipelineResponseMock = (
+  overrideResponse: Partial<Extract<StartPipelineResponse, object>> = {},
+): StartPipelineResponse => ({
+  operationId: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  ...overrideResponse,
+})
+
+export const getListProjectsResponseMock = (
+  overrideResponse: Partial<Extract<ListProjectsResponse, object>> = {},
+): ListProjectsResponse => ({
+  projects: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+    () => ({
+      id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      path: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+    }),
+  ),
+  ...overrideResponse,
+})
+
+export const getCreateProjectResponseMock = (
+  overrideResponse: Partial<Extract<ProjectSummary, object>> = {},
+): ProjectSummary => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  path: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+  ...overrideResponse,
+})
+
+export const getPutCurrentProjectResponseMock = (
+  overrideResponse: Partial<Extract<ProjectSummary, object>> = {},
+): ProjectSummary => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  path: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+  ...overrideResponse,
+})
+
+export const getExportCurrentProjectResponseMock = (): ArrayBuffer =>
+  new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))
+
+export const getImportProjectResponseMock = (
+  overrideResponse: Partial<Extract<ProjectSummary, object>> = {},
+): ProjectSummary => ({
+  id: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  path: faker.string.alpha({ length: { min: 10, max: 20 } }),
+  updatedAtMs: faker.helpers.arrayElement([faker.number.int({ min: 0 }), undefined]),
+  ...overrideResponse,
+})
+
+export const getGetSceneBinResponseMock = (): ArrayBuffer =>
+  new ArrayBuffer(faker.number.int({ min: 1, max: 64 }))
+
+export const getGetSceneJsonResponseFontPredictionMock = (
+  overrideResponse: Partial<FontPrediction> = {},
+): FontPrediction => ({
+  ...{
+    angleDeg: faker.number.float({ fractionDigits: 2 }),
+    direction: faker.helpers.arrayElement(Object.values(TextDirection)),
+    fontSizePx: faker.number.float({ fractionDigits: 2 }),
+    lineHeight: faker.number.float({ fractionDigits: 2 }),
+    namedFonts: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        index: faker.number.int({ min: 0 }),
+        language: faker.helpers.arrayElement([
+          faker.helpers.arrayElement([faker.string.alpha({ length: { min: 10, max: 20 } }), null]),
+          undefined,
+        ]),
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        probability: faker.number.float({ fractionDigits: 2 }),
+        serif: faker.datatype.boolean(),
+      }),
+    ),
+    strokeColor: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => faker.number.int({ min: 0 }),
+    ),
+    strokeWidthPx: faker.number.float({ fractionDigits: 2 }),
+    textColor: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => faker.number.int({ min: 0 }),
+    ),
+    topFonts: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(
+      () => ({
+        index: faker.number.int({ min: 0 }),
+        score: faker.number.float({ fractionDigits: 2 }),
+      }),
+    ),
+  },
+  ...overrideResponse,
+})
+
+export const getGetSceneJsonResponseTransformMock = (
+  overrideResponse: Partial<Transform> = {},
+): Transform => ({
+  ...{
+    height: faker.number.float({ fractionDigits: 2 }),
+    rotationDeg: faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), undefined]),
+    width: faker.number.float({ fractionDigits: 2 }),
+    x: faker.number.float({ fractionDigits: 2 }),
+    y: faker.number.float({ fractionDigits: 2 }),
+  },
+  ...overrideResponse,
+})
+
+export const getGetSceneJsonResponseTextShaderEffectMock = (
+  overrideResponse: Partial<TextShaderEffect> = {},
+): TextShaderEffect => ({
+  ...{
+    bold: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]),
+    italic: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]),
+  },
+  ...overrideResponse,
+})
+
+export const getGetSceneJsonResponseTextStrokeStyleMock = (
+  overrideResponse: Partial<TextStrokeStyle> = {},
+): TextStrokeStyle => ({
+  ...{
+    color: faker.helpers.arrayElement([
+      Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+        faker.number.int({ min: 0 }),
+      ),
+      undefined,
+    ]),
+    enabled: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]),
+    widthPx: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]),
+      undefined,
+    ]),
+  },
+  ...overrideResponse,
+})
+
+export const getGetSceneJsonResponseTextStyleMock = (
+  overrideResponse: Partial<TextStyle> = {},
+): TextStyle => ({
+  ...{
+    color: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+      faker.number.int({ min: 0 }),
+    ),
+    effect: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([null, { ...getGetSceneJsonResponseTextShaderEffectMock() }]),
+      undefined,
+    ]),
+    fontFamilies: Array.from(
+      { length: faker.number.int({ min: 1, max: 10 }) },
+      (_, i) => i + 1,
+    ).map(() => faker.string.alpha({ length: { min: 10, max: 20 } })),
+    fontSize: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]),
+      undefined,
+    ]),
+    stroke: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([null, { ...getGetSceneJsonResponseTextStrokeStyleMock() }]),
+      undefined,
+    ]),
+    textAlign: faker.helpers.arrayElement([
+      faker.helpers.arrayElement([null, faker.helpers.arrayElement(Object.values(TextAlign))]),
+      undefined,
+    ]),
+  },
+  ...overrideResponse,
+})
+
+export const getGetSceneJsonResponseMock = (
+  overrideResponse: Partial<Extract<SceneSnapshot, object>> = {},
+): SceneSnapshot => ({
+  epoch: faker.number.int({ min: 0 }),
+  scene: {
+    pages: {
+      [faker.string.alphanumeric(5)]: {
+        height: faker.number.int({ min: 0 }),
+        id: faker.string.uuid(),
+        name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+        nodes: {
+          [faker.string.alphanumeric(5)]: {
+            id: faker.string.uuid(),
+            kind: faker.helpers.arrayElement([
+              {
+                image: {
+                  blob: faker.string.alpha({ length: { min: 10, max: 20 } }),
+                  name: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      faker.string.alpha({ length: { min: 10, max: 20 } }),
+                      null,
+                    ]),
+                    undefined,
+                  ]),
+                  naturalHeight: faker.number.int({ min: 0 }),
+                  naturalWidth: faker.number.int({ min: 0 }),
+                  opacity: faker.helpers.arrayElement([
+                    faker.number.float({ fractionDigits: 2 }),
+                    undefined,
+                  ]),
+                  role: faker.helpers.arrayElement(Object.values(ImageRole)),
+                },
+              },
+              {
+                text: {
+                  confidence: faker.helpers.arrayElement([
+                    faker.number.float({ fractionDigits: 2 }),
+                    undefined,
+                  ]),
+                  detectedFontSizePx: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]),
+                    undefined,
+                  ]),
+                  detector: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      faker.string.alpha({ length: { min: 10, max: 20 } }),
+                      null,
+                    ]),
+                    undefined,
+                  ]),
+                  fontPrediction: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      null,
+                      { ...getGetSceneJsonResponseFontPredictionMock() },
+                    ]),
+                    undefined,
+                  ]),
+                  linePolygons: faker.helpers.arrayElement([
+                    Array.from(
+                      { length: faker.number.int({ min: 1, max: 10 }) },
+                      (_, i) => i + 1,
+                    ).map(() =>
+                      Array.from(
+                        { length: faker.number.int({ min: 1, max: 10 }) },
+                        (_, i) => i + 1,
+                      ).map(() =>
+                        Array.from(
+                          { length: faker.number.int({ min: 1, max: 10 }) },
+                          (_, i) => i + 1,
+                        ).map(() => faker.number.float({ fractionDigits: 2 })),
+                      ),
+                    ),
+                    undefined,
+                  ]),
+                  lockLayoutBox: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]),
+                  renderedDirection: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      null,
+                      faker.helpers.arrayElement(Object.values(TextDirection)),
+                    ]),
+                    undefined,
+                  ]),
+                  rotationDeg: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([faker.number.float({ fractionDigits: 2 }), null]),
+                    undefined,
+                  ]),
+                  sourceDirection: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      null,
+                      faker.helpers.arrayElement(Object.values(TextDirection)),
+                    ]),
+                    undefined,
+                  ]),
+                  sourceLang: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      faker.string.alpha({ length: { min: 10, max: 20 } }),
+                      null,
+                    ]),
+                    undefined,
+                  ]),
+                  sprite: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      null,
+                      faker.string.alpha({ length: { min: 10, max: 20 } }),
+                    ]),
+                    undefined,
+                  ]),
+                  spriteTransform: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      null,
+                      { ...getGetSceneJsonResponseTransformMock() },
+                    ]),
+                    undefined,
+                  ]),
+                  style: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      null,
+                      { ...getGetSceneJsonResponseTextStyleMock() },
+                    ]),
+                    undefined,
+                  ]),
+                  text: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      faker.string.alpha({ length: { min: 10, max: 20 } }),
+                      null,
+                    ]),
+                    undefined,
+                  ]),
+                  translation: faker.helpers.arrayElement([
+                    faker.helpers.arrayElement([
+                      faker.string.alpha({ length: { min: 10, max: 20 } }),
+                      null,
+                    ]),
+                    undefined,
+                  ]),
+                },
+              },
+              {
+                mask: {
+                  blob: faker.string.alpha({ length: { min: 10, max: 20 } }),
+                  role: faker.helpers.arrayElement(Object.values(MaskRole)),
+                },
+              },
+            ]),
+            transform: faker.helpers.arrayElement([
+              {
+                height: faker.number.float({ fractionDigits: 2 }),
+                rotationDeg: faker.helpers.arrayElement([
+                  faker.number.float({ fractionDigits: 2 }),
+                  undefined,
+                ]),
+                width: faker.number.float({ fractionDigits: 2 }),
+                x: faker.number.float({ fractionDigits: 2 }),
+                y: faker.number.float({ fractionDigits: 2 }),
+              },
+              undefined,
+            ]),
+            visible: faker.datatype.boolean(),
+          },
+        },
+        width: faker.number.int({ min: 0 }),
+      },
+    },
+    project: {
+      createdAt: faker.date.past().toISOString().slice(0, 19) + 'Z',
+      name: faker.string.alpha({ length: { min: 10, max: 20 } }),
+      style: faker.helpers.arrayElement([
+        {
+          defaultFont: faker.helpers.arrayElement([
+            faker.helpers.arrayElement([
+              faker.string.alpha({ length: { min: 10, max: 20 } }),
+              null,
+            ]),
+            undefined,
+          ]),
+        },
+        undefined,
+      ]),
+      updatedAt: faker.date.past().toISOString().slice(0, 19) + 'Z',
+    },
+  },
+  ...overrideResponse,
+})
+
+export const getGetBlobMockHandler = (
+  overrideResponse?:
+    | ArrayBuffer
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/blobs/:hash',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      const binaryBody =
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetBlobResponseMock()
+      return HttpResponse.arrayBuffer(
+        binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0),
+        { status: 200, headers: { 'Content-Type': 'application/octet-stream' } },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetConfigMockHandler = (
+  overrideResponse?:
+    | AppConfig
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<AppConfig> | AppConfig),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/config',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetConfigResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getPatchConfigMockHandler = (
+  overrideResponse?:
+    | AppConfig
+    | ((info: Parameters<Parameters<typeof http.patch>[1]>[0]) => Promise<AppConfig> | AppConfig),
+  options?: RequestHandlerOptions,
+) => {
+  return http.patch(
+    '*/config',
+    async (info: Parameters<Parameters<typeof http.patch>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getPatchConfigResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getSetProviderSecretMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.put>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.put(
+    '*/config/providers/:id/secret',
+    async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getClearProviderSecretMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.delete(
+    '*/config/providers/:id/secret',
+    async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getListDownloadsMockHandler = (
+  overrideResponse?:
+    | ListDownloadsResponse
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<ListDownloadsResponse> | ListDownloadsResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/downloads',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getListDownloadsResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getStartDownloadMockHandler = (
+  overrideResponse?:
+    | StartDownloadResponse
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<StartDownloadResponse> | StartDownloadResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/downloads',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getStartDownloadResponseMock(),
+        { status: 202 },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetEngineCatalogMockHandler = (
+  overrideResponse?:
+    | EngineCatalog
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<EngineCatalog> | EngineCatalog),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/engines',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetEngineCatalogResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getEventsMockHandler = (
+  overrideResponse?:
+    | AppEvent
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<AppEvent> | AppEvent),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/events',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getEventsResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getListFontsMockHandler = (
+  overrideResponse?:
+    | FontFaceInfo[]
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<FontFaceInfo[]> | FontFaceInfo[]),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/fonts',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getListFontsResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetGoogleFontsCatalogMockHandler = (
+  overrideResponse?:
+    | GoogleFontCatalog
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<GoogleFontCatalog> | GoogleFontCatalog),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/google-fonts',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetGoogleFontsCatalogResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getFetchGoogleFontMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/google-fonts/:family/fetch',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getGetGoogleFontFileMockHandler = (
+  overrideResponse?:
+    | ArrayBuffer
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/google-fonts/:family/:file',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      const binaryBody =
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetGoogleFontFileResponseMock()
+      return HttpResponse.arrayBuffer(
+        binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0),
+        { status: 200, headers: { 'Content-Type': 'font/ttf' } },
+      )
+    },
+    options,
+  )
+}
+
+export const getApplyCommandMockHandler = (
+  overrideResponse?:
+    | HistoryResult
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<HistoryResult> | HistoryResult),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/history/apply',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getApplyCommandResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getRedoMockHandler = (
+  overrideResponse?:
+    | HistoryResult
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<HistoryResult> | HistoryResult),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/history/redo',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getRedoResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getUndoMockHandler = (
+  overrideResponse?:
+    | HistoryResult
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<HistoryResult> | HistoryResult),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/history/undo',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getUndoResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetCatalogMockHandler = (
+  overrideResponse?:
+    | LlmCatalog
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<LlmCatalog> | LlmCatalog),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/llm/catalog',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetCatalogResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetCurrentLlmMockHandler = (
+  overrideResponse?:
+    | LlmState
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<LlmState> | LlmState),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/llm/current',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetCurrentLlmResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getPutCurrentLlmMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.put>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.put(
+    '*/llm/current',
+    async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getDeleteCurrentLlmMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.delete(
+    '*/llm/current',
+    async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getGetMetaMockHandler = (
+  overrideResponse?:
+    | MetaInfo
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<MetaInfo> | MetaInfo),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/meta',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetMetaResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getListOperationsMockHandler = (
+  overrideResponse?:
+    | ListOperationsResponse
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<ListOperationsResponse> | ListOperationsResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/operations',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getListOperationsResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getCancelOperationMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.delete(
+    '*/operations/:id',
+    async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getCreatePagesMockHandler = (
+  overrideResponse?:
+    | CreatePagesResponse
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<CreatePagesResponse> | CreatePagesResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/pages',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getCreatePagesResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getCreatePagesFromPathsMockHandler = (
+  overrideResponse?:
+    | CreatePagesResponse
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<CreatePagesResponse> | CreatePagesResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/pages/from-paths',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getCreatePagesFromPathsResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getAddImageLayerMockHandler = (
+  overrideResponse?:
+    | AddImageLayerResponse
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<AddImageLayerResponse> | AddImageLayerResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/pages/:id/image-layers',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getAddImageLayerResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getPutMaskMockHandler = (
+  overrideResponse?:
+    | PutMaskResponse
+    | ((
+        info: Parameters<Parameters<typeof http.put>[1]>[0],
+      ) => Promise<PutMaskResponse> | PutMaskResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.put(
+    '*/pages/:id/masks/:role',
+    async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getPutMaskResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetPageThumbnailMockHandler = (
+  overrideResponse?:
+    | ArrayBuffer
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/pages/:id/thumbnail',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      const binaryBody =
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetPageThumbnailResponseMock()
+      return HttpResponse.arrayBuffer(
+        binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0),
+        { status: 200, headers: { 'Content-Type': 'image/webp' } },
+      )
+    },
+    options,
+  )
+}
+
+export const getStartPipelineMockHandler = (
+  overrideResponse?:
+    | StartPipelineResponse
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<StartPipelineResponse> | StartPipelineResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/pipelines',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getStartPipelineResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getListProjectsMockHandler = (
+  overrideResponse?:
+    | ListProjectsResponse
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<ListProjectsResponse> | ListProjectsResponse),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/projects',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getListProjectsResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getCreateProjectMockHandler = (
+  overrideResponse?:
+    | ProjectSummary
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ProjectSummary> | ProjectSummary),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/projects',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getCreateProjectResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getPutCurrentProjectMockHandler = (
+  overrideResponse?:
+    | ProjectSummary
+    | ((
+        info: Parameters<Parameters<typeof http.put>[1]>[0],
+      ) => Promise<ProjectSummary> | ProjectSummary),
+  options?: RequestHandlerOptions,
+) => {
+  return http.put(
+    '*/projects/current',
+    async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getPutCurrentProjectResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getDeleteCurrentProjectMockHandler = (
+  overrideResponse?:
+    | void
+    | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<void> | void),
+  options?: RequestHandlerOptions,
+) => {
+  return http.delete(
+    '*/projects/current',
+    async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
+      await delay(0)
+      if (typeof overrideResponse === 'function') {
+        await overrideResponse(info)
+      }
+
+      return new HttpResponse(null, { status: 204 })
+    },
+    options,
+  )
+}
+
+export const getExportCurrentProjectMockHandler = (
+  overrideResponse?:
+    | ArrayBuffer
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ArrayBuffer> | ArrayBuffer),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/projects/current/export',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      const binaryBody =
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getExportCurrentProjectResponseMock()
+      return HttpResponse.arrayBuffer(
+        binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0),
+        { status: 200, headers: { 'Content-Type': 'application/octet-stream' } },
+      )
+    },
+    options,
+  )
+}
+
+export const getImportProjectMockHandler = (
+  overrideResponse?:
+    | ProjectSummary
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ProjectSummary> | ProjectSummary),
+  options?: RequestHandlerOptions,
+) => {
+  return http.post(
+    '*/projects/import',
+    async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getImportProjectResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetSceneBinMockHandler = (
+  overrideResponse?:
+    | ArrayBuffer
+    | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<ArrayBuffer> | ArrayBuffer),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/scene.bin',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      const binaryBody =
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetSceneBinResponseMock()
+      return HttpResponse.arrayBuffer(
+        binaryBody instanceof ArrayBuffer ? binaryBody : new ArrayBuffer(0),
+        { status: 200, headers: { 'Content-Type': 'application/octet-stream' } },
+      )
+    },
+    options,
+  )
+}
+
+export const getGetSceneJsonMockHandler = (
+  overrideResponse?:
+    | SceneSnapshot
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<SceneSnapshot> | SceneSnapshot),
+  options?: RequestHandlerOptions,
+) => {
+  return http.get(
+    '*/scene.json',
+    async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
+      await delay(0)
+
+      return HttpResponse.json(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === 'function'
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetSceneJsonResponseMock(),
+        { status: 200 },
+      )
+    },
+    options,
+  )
+}
+export const getDefaultMock = () => [
+  getGetBlobMockHandler(),
+  getGetConfigMockHandler(),
+  getPatchConfigMockHandler(),
+  getSetProviderSecretMockHandler(),
+  getClearProviderSecretMockHandler(),
+  getListDownloadsMockHandler(),
+  getStartDownloadMockHandler(),
+  getGetEngineCatalogMockHandler(),
+  getEventsMockHandler(),
+  getListFontsMockHandler(),
+  getGetGoogleFontsCatalogMockHandler(),
+  getFetchGoogleFontMockHandler(),
+  getGetGoogleFontFileMockHandler(),
+  getApplyCommandMockHandler(),
+  getRedoMockHandler(),
+  getUndoMockHandler(),
+  getGetCatalogMockHandler(),
+  getGetCurrentLlmMockHandler(),
+  getPutCurrentLlmMockHandler(),
+  getDeleteCurrentLlmMockHandler(),
+  getGetMetaMockHandler(),
+  getListOperationsMockHandler(),
+  getCancelOperationMockHandler(),
+  getCreatePagesMockHandler(),
+  getCreatePagesFromPathsMockHandler(),
+  getAddImageLayerMockHandler(),
+  getPutMaskMockHandler(),
+  getGetPageThumbnailMockHandler(),
+  getStartPipelineMockHandler(),
+  getListProjectsMockHandler(),
+  getCreateProjectMockHandler(),
+  getPutCurrentProjectMockHandler(),
+  getDeleteCurrentProjectMockHandler(),
+  getExportCurrentProjectMockHandler(),
+  getImportProjectMockHandler(),
+  getGetSceneBinMockHandler(),
+  getGetSceneJsonMockHandler(),
+]

ui/lib/api/documents/documents.ts

@@ -1,646 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useMutation, useQuery } from '@tanstack/react-query'
-import type {
-  DataTag,
-  DefinedInitialDataOptions,
-  DefinedUseQueryResult,
-  MutationFunction,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  UndefinedInitialDataOptions,
-  UseMutationOptions,
-  UseMutationResult,
-  UseQueryOptions,
-  UseQueryResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type {
-  ApiError,
-  DocumentDetail,
-  DocumentSummary,
-  GetDocumentThumbnailParams,
-  ImportDocumentsBody,
-  ImportDocumentsParams,
-  ImportResult,
-  ReorderRequest,
-  UpdateDocumentStyleRequest,
-} from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getListDocumentsUrl = () => {
-  return `/api/v1/documents`
-}
-
-export const listDocuments = async (options?: RequestInit): Promise<DocumentSummary[]> => {
-  return fetchApi<DocumentSummary[]>(getListDocumentsUrl(), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getListDocumentsQueryKey = () => {
-  return [`/api/v1/documents`] as const
-}
-
-export const getListDocumentsQueryOptions = <
-  TData = Awaited<ReturnType<typeof listDocuments>>,
-  TError = ApiError,
->(options?: {
-  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDocuments>>, TError, TData>>
-  request?: SecondParameter<typeof fetchApi>
-}) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getListDocumentsQueryKey()
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof listDocuments>>> = ({ signal }) =>
-    listDocuments({ signal, ...requestOptions })
-
-  return { queryKey, queryFn, gcTime: 300000, retry: 1, ...queryOptions } as UseQueryOptions<
-    Awaited<ReturnType<typeof listDocuments>>,
-    TError,
-    TData
-  > & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type ListDocumentsQueryResult = NonNullable<Awaited<ReturnType<typeof listDocuments>>>
-export type ListDocumentsQueryError = ApiError
-
-export function useListDocuments<
-  TData = Awaited<ReturnType<typeof listDocuments>>,
-  TError = ApiError,
->(
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDocuments>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof listDocuments>>,
-          TError,
-          Awaited<ReturnType<typeof listDocuments>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useListDocuments<
-  TData = Awaited<ReturnType<typeof listDocuments>>,
-  TError = ApiError,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDocuments>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof listDocuments>>,
-          TError,
-          Awaited<ReturnType<typeof listDocuments>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useListDocuments<
-  TData = Awaited<ReturnType<typeof listDocuments>>,
-  TError = ApiError,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDocuments>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useListDocuments<
-  TData = Awaited<ReturnType<typeof listDocuments>>,
-  TError = ApiError,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDocuments>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getListDocumentsQueryOptions(options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}
-
-export const getImportDocumentsUrl = (params?: ImportDocumentsParams) => {
-  const normalizedParams = new URLSearchParams()
-
-  Object.entries(params || {}).forEach(([key, value]) => {
-    if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
-    }
-  })
-
-  const stringifiedParams = normalizedParams.toString()
-
-  return stringifiedParams.length > 0
-    ? `/api/v1/documents?${stringifiedParams}`
-    : `/api/v1/documents`
-}
-
-export const importDocuments = async (
-  importDocumentsBody: ImportDocumentsBody,
-  params?: ImportDocumentsParams,
-  options?: RequestInit,
-): Promise<ImportResult> => {
-  const formData = new FormData()
-  importDocumentsBody.files.forEach((value) => formData.append(`files`, value))
-
-  return fetchApi<ImportResult>(getImportDocumentsUrl(params), {
-    ...options,
-    method: 'POST',
-    body: formData,
-  })
-}
-
-export const getImportDocumentsMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof importDocuments>>,
-    TError,
-    { data: ImportDocumentsBody; params?: ImportDocumentsParams },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof importDocuments>>,
-  TError,
-  { data: ImportDocumentsBody; params?: ImportDocumentsParams },
-  TContext
-> => {
-  const mutationKey = ['importDocuments']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof importDocuments>>,
-    { data: ImportDocumentsBody; params?: ImportDocumentsParams }
-  > = (props) => {
-    const { data, params } = props ?? {}
-
-    return importDocuments(data, params, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type ImportDocumentsMutationResult = NonNullable<Awaited<ReturnType<typeof importDocuments>>>
-export type ImportDocumentsMutationBody = ImportDocumentsBody
-export type ImportDocumentsMutationError = ApiError
-
-export const useImportDocuments = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof importDocuments>>,
-      TError,
-      { data: ImportDocumentsBody; params?: ImportDocumentsParams },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof importDocuments>>,
-  TError,
-  { data: ImportDocumentsBody; params?: ImportDocumentsParams },
-  TContext
-> => {
-  return useMutation(getImportDocumentsMutationOptions(options), queryClient)
-}
-export const getReorderDocumentsUrl = () => {
-  return `/api/v1/documents/order`
-}
-
-export const reorderDocuments = async (
-  reorderRequest: ReorderRequest,
-  options?: RequestInit,
-): Promise<DocumentSummary[]> => {
-  return fetchApi<DocumentSummary[]>(getReorderDocumentsUrl(), {
-    ...options,
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(reorderRequest),
-  })
-}
-
-export const getReorderDocumentsMutationOptions = <
-  TError = ApiError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof reorderDocuments>>,
-    TError,
-    { data: ReorderRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof reorderDocuments>>,
-  TError,
-  { data: ReorderRequest },
-  TContext
-> => {
-  const mutationKey = ['reorderDocuments']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof reorderDocuments>>,
-    { data: ReorderRequest }
-  > = (props) => {
-    const { data } = props ?? {}
-
-    return reorderDocuments(data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type ReorderDocumentsMutationResult = NonNullable<
-  Awaited<ReturnType<typeof reorderDocuments>>
->
-export type ReorderDocumentsMutationBody = ReorderRequest
-export type ReorderDocumentsMutationError = ApiError
-
-export const useReorderDocuments = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof reorderDocuments>>,
-      TError,
-      { data: ReorderRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof reorderDocuments>>,
-  TError,
-  { data: ReorderRequest },
-  TContext
-> => {
-  return useMutation(getReorderDocumentsMutationOptions(options), queryClient)
-}
-export const getGetDocumentUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}`
-}
-
-export const getDocument = async (
-  documentId: string,
-  options?: RequestInit,
-): Promise<DocumentDetail> => {
-  return fetchApi<DocumentDetail>(getGetDocumentUrl(documentId), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getGetDocumentQueryKey = (documentId: string) => {
-  return [`/api/v1/documents/${documentId}`] as const
-}
-
-export const getGetDocumentQueryOptions = <
-  TData = Awaited<ReturnType<typeof getDocument>>,
-  TError = ApiError,
->(
-  documentId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getGetDocumentQueryKey(documentId)
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof getDocument>>> = ({ signal }) =>
-    getDocument(documentId, { signal, ...requestOptions })
-
-  return {
-    queryKey,
-    queryFn,
-    enabled: !!documentId,
-    gcTime: 300000,
-    retry: 1,
-    ...queryOptions,
-  } as UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-}
-
-export type GetDocumentQueryResult = NonNullable<Awaited<ReturnType<typeof getDocument>>>
-export type GetDocumentQueryError = ApiError
-
-export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ApiError>(
-  documentId: string,
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getDocument>>,
-          TError,
-          Awaited<ReturnType<typeof getDocument>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ApiError>(
-  documentId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getDocument>>,
-          TError,
-          Awaited<ReturnType<typeof getDocument>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ApiError>(
-  documentId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useGetDocument<TData = Awaited<ReturnType<typeof getDocument>>, TError = ApiError>(
-  documentId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getDocument>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getGetDocumentQueryOptions(documentId, options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}
-
-export const getUpdateDocumentStyleUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/style`
-}
-
-export const updateDocumentStyle = async (
-  documentId: string,
-  updateDocumentStyleRequest: UpdateDocumentStyleRequest,
-  options?: RequestInit,
-): Promise<UpdateDocumentStyleRequest> => {
-  return fetchApi<UpdateDocumentStyleRequest>(getUpdateDocumentStyleUrl(documentId), {
-    ...options,
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(updateDocumentStyleRequest),
-  })
-}
-
-export const getUpdateDocumentStyleMutationOptions = <
-  TError = ApiError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof updateDocumentStyle>>,
-    TError,
-    { documentId: string; data: UpdateDocumentStyleRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof updateDocumentStyle>>,
-  TError,
-  { documentId: string; data: UpdateDocumentStyleRequest },
-  TContext
-> => {
-  const mutationKey = ['updateDocumentStyle']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof updateDocumentStyle>>,
-    { documentId: string; data: UpdateDocumentStyleRequest }
-  > = (props) => {
-    const { documentId, data } = props ?? {}
-
-    return updateDocumentStyle(documentId, data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type UpdateDocumentStyleMutationResult = NonNullable<
-  Awaited<ReturnType<typeof updateDocumentStyle>>
->
-export type UpdateDocumentStyleMutationBody = UpdateDocumentStyleRequest
-export type UpdateDocumentStyleMutationError = ApiError
-
-export const useUpdateDocumentStyle = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof updateDocumentStyle>>,
-      TError,
-      { documentId: string; data: UpdateDocumentStyleRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof updateDocumentStyle>>,
-  TError,
-  { documentId: string; data: UpdateDocumentStyleRequest },
-  TContext
-> => {
-  return useMutation(getUpdateDocumentStyleMutationOptions(options), queryClient)
-}
-export const getGetDocumentThumbnailUrl = (
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-) => {
-  const normalizedParams = new URLSearchParams()
-
-  Object.entries(params || {}).forEach(([key, value]) => {
-    if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
-    }
-  })
-
-  const stringifiedParams = normalizedParams.toString()
-
-  return stringifiedParams.length > 0
-    ? `/api/v1/documents/${documentId}/thumbnail?${stringifiedParams}`
-    : `/api/v1/documents/${documentId}/thumbnail`
-}
-
-export const getDocumentThumbnail = async (
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-  options?: RequestInit,
-): Promise<Blob> => {
-  return fetchApi<Blob>(getGetDocumentThumbnailUrl(documentId, params), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getGetDocumentThumbnailQueryKey = (
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-) => {
-  return [`/api/v1/documents/${documentId}/thumbnail`, ...(params ? [params] : [])] as const
-}
-
-export const getGetDocumentThumbnailQueryOptions = <
-  TData = Awaited<ReturnType<typeof getDocumentThumbnail>>,
-  TError = ApiError,
->(
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<Awaited<ReturnType<typeof getDocumentThumbnail>>, TError, TData>
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getGetDocumentThumbnailQueryKey(documentId, params)
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof getDocumentThumbnail>>> = ({ signal }) =>
-    getDocumentThumbnail(documentId, params, { signal, ...requestOptions })
-
-  return {
-    queryKey,
-    queryFn,
-    enabled: !!documentId,
-    gcTime: 300000,
-    retry: 1,
-    ...queryOptions,
-  } as UseQueryOptions<Awaited<ReturnType<typeof getDocumentThumbnail>>, TError, TData> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-}
-
-export type GetDocumentThumbnailQueryResult = NonNullable<
-  Awaited<ReturnType<typeof getDocumentThumbnail>>
->
-export type GetDocumentThumbnailQueryError = ApiError
-
-export function useGetDocumentThumbnail<
-  TData = Awaited<ReturnType<typeof getDocumentThumbnail>>,
-  TError = ApiError,
->(
-  documentId: string,
-  params: undefined | GetDocumentThumbnailParams,
-  options: {
-    query: Partial<
-      UseQueryOptions<Awaited<ReturnType<typeof getDocumentThumbnail>>, TError, TData>
-    > &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getDocumentThumbnail>>,
-          TError,
-          Awaited<ReturnType<typeof getDocumentThumbnail>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetDocumentThumbnail<
-  TData = Awaited<ReturnType<typeof getDocumentThumbnail>>,
-  TError = ApiError,
->(
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<Awaited<ReturnType<typeof getDocumentThumbnail>>, TError, TData>
-    > &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getDocumentThumbnail>>,
-          TError,
-          Awaited<ReturnType<typeof getDocumentThumbnail>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetDocumentThumbnail<
-  TData = Awaited<ReturnType<typeof getDocumentThumbnail>>,
-  TError = ApiError,
->(
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<Awaited<ReturnType<typeof getDocumentThumbnail>>, TError, TData>
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useGetDocumentThumbnail<
-  TData = Awaited<ReturnType<typeof getDocumentThumbnail>>,
-  TError = ApiError,
->(
-  documentId: string,
-  params?: GetDocumentThumbnailParams,
-  options?: {
-    query?: Partial<
-      UseQueryOptions<Awaited<ReturnType<typeof getDocumentThumbnail>>, TError, TData>
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getGetDocumentThumbnailQueryOptions(documentId, params, options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}

ui/lib/api/downloads/downloads.ts

@@ -1,127 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useQuery } from '@tanstack/react-query'
-import type {
-  DataTag,
-  DefinedInitialDataOptions,
-  DefinedUseQueryResult,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  UndefinedInitialDataOptions,
-  UseQueryOptions,
-  UseQueryResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type { DownloadState } from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getListDownloadsUrl = () => {
-  return `/api/v1/downloads`
-}
-
-export const listDownloads = async (options?: RequestInit): Promise<DownloadState[]> => {
-  return fetchApi<DownloadState[]>(getListDownloadsUrl(), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getListDownloadsQueryKey = () => {
-  return [`/api/v1/downloads`] as const
-}
-
-export const getListDownloadsQueryOptions = <
-  TData = Awaited<ReturnType<typeof listDownloads>>,
-  TError = unknown,
->(options?: {
-  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDownloads>>, TError, TData>>
-  request?: SecondParameter<typeof fetchApi>
-}) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getListDownloadsQueryKey()
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof listDownloads>>> = ({ signal }) =>
-    listDownloads({ signal, ...requestOptions })
-
-  return { queryKey, queryFn, gcTime: 300000, retry: 1, ...queryOptions } as UseQueryOptions<
-    Awaited<ReturnType<typeof listDownloads>>,
-    TError,
-    TData
-  > & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type ListDownloadsQueryResult = NonNullable<Awaited<ReturnType<typeof listDownloads>>>
-export type ListDownloadsQueryError = unknown
-
-export function useListDownloads<
-  TData = Awaited<ReturnType<typeof listDownloads>>,
-  TError = unknown,
->(
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDownloads>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof listDownloads>>,
-          TError,
-          Awaited<ReturnType<typeof listDownloads>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useListDownloads<
-  TData = Awaited<ReturnType<typeof listDownloads>>,
-  TError = unknown,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDownloads>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof listDownloads>>,
-          TError,
-          Awaited<ReturnType<typeof listDownloads>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useListDownloads<
-  TData = Awaited<ReturnType<typeof listDownloads>>,
-  TError = unknown,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDownloads>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useListDownloads<
-  TData = Awaited<ReturnType<typeof listDownloads>>,
-  TError = unknown,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listDownloads>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getListDownloadsQueryOptions(options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}

ui/lib/api/exports/exports.ts

@@ -1,250 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useMutation, useQuery } from '@tanstack/react-query'
-import type {
-  DataTag,
-  DefinedInitialDataOptions,
-  DefinedUseQueryResult,
-  MutationFunction,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  UndefinedInitialDataOptions,
-  UseMutationOptions,
-  UseMutationResult,
-  UseQueryOptions,
-  UseQueryResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type { ApiError, ExportBatchRequest, ExportDocumentParams, ExportResult } from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getExportDocumentUrl = (
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-) => {
-  const normalizedParams = new URLSearchParams()
-
-  Object.entries(params || {}).forEach(([key, value]) => {
-    if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
-    }
-  })
-
-  const stringifiedParams = normalizedParams.toString()
-
-  return stringifiedParams.length > 0
-    ? `/api/v1/documents/${documentId}/export/${format}?${stringifiedParams}`
-    : `/api/v1/documents/${documentId}/export/${format}`
-}
-
-export const exportDocument = async (
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-  options?: RequestInit,
-): Promise<Blob> => {
-  return fetchApi<Blob>(getExportDocumentUrl(documentId, format, params), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getExportDocumentQueryKey = (
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-) => {
-  return [`/api/v1/documents/${documentId}/export/${format}`, ...(params ? [params] : [])] as const
-}
-
-export const getExportDocumentQueryOptions = <
-  TData = Awaited<ReturnType<typeof exportDocument>>,
-  TError = ApiError,
->(
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof exportDocument>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getExportDocumentQueryKey(documentId, format, params)
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof exportDocument>>> = ({ signal }) =>
-    exportDocument(documentId, format, params, { signal, ...requestOptions })
-
-  return {
-    queryKey,
-    queryFn,
-    enabled: !!(documentId && format),
-    gcTime: 300000,
-    retry: 1,
-    ...queryOptions,
-  } as UseQueryOptions<Awaited<ReturnType<typeof exportDocument>>, TError, TData> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-}
-
-export type ExportDocumentQueryResult = NonNullable<Awaited<ReturnType<typeof exportDocument>>>
-export type ExportDocumentQueryError = ApiError
-
-export function useExportDocument<
-  TData = Awaited<ReturnType<typeof exportDocument>>,
-  TError = ApiError,
->(
-  documentId: string,
-  format: string,
-  params: undefined | ExportDocumentParams,
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof exportDocument>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof exportDocument>>,
-          TError,
-          Awaited<ReturnType<typeof exportDocument>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useExportDocument<
-  TData = Awaited<ReturnType<typeof exportDocument>>,
-  TError = ApiError,
->(
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof exportDocument>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof exportDocument>>,
-          TError,
-          Awaited<ReturnType<typeof exportDocument>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useExportDocument<
-  TData = Awaited<ReturnType<typeof exportDocument>>,
-  TError = ApiError,
->(
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof exportDocument>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useExportDocument<
-  TData = Awaited<ReturnType<typeof exportDocument>>,
-  TError = ApiError,
->(
-  documentId: string,
-  format: string,
-  params?: ExportDocumentParams,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof exportDocument>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getExportDocumentQueryOptions(documentId, format, params, options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}
-
-export const getBatchExportUrl = () => {
-  return `/api/v1/exports`
-}
-
-export const batchExport = async (
-  exportBatchRequest: ExportBatchRequest,
-  options?: RequestInit,
-): Promise<ExportResult> => {
-  return fetchApi<ExportResult>(getBatchExportUrl(), {
-    ...options,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(exportBatchRequest),
-  })
-}
-
-export const getBatchExportMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof batchExport>>,
-    TError,
-    { data: ExportBatchRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof batchExport>>,
-  TError,
-  { data: ExportBatchRequest },
-  TContext
-> => {
-  const mutationKey = ['batchExport']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof batchExport>>,
-    { data: ExportBatchRequest }
-  > = (props) => {
-    const { data } = props ?? {}
-
-    return batchExport(data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type BatchExportMutationResult = NonNullable<Awaited<ReturnType<typeof batchExport>>>
-export type BatchExportMutationBody = ExportBatchRequest
-export type BatchExportMutationError = ApiError
-
-export const useBatchExport = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof batchExport>>,
-      TError,
-      { data: ExportBatchRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof batchExport>>,
-  TError,
-  { data: ExportBatchRequest },
-  TContext
-> => {
-  return useMutation(getBatchExportMutationOptions(options), queryClient)
-}

ui/lib/api/fetch.ts

@@ -1,7 +1,25 @@
+export class ApiError extends Error {
+  readonly status: number
+  readonly body: unknown
+  constructor(status: number, message: string, body?: unknown) {
+    super(message)
+    this.name = 'ApiError'
+    this.status = status
+    this.body = body
+  }
+}
+
 export const fetchApi = async <T>(url: string, options?: RequestInit): Promise<T> => {
   const res = await fetch(url, options)
   if (!res.ok) {
-    throw await res.json().catch(() => ({ status: res.status, message: res.statusText }))
+    const body = await res.json().catch(() => null)
+    const message =
+      (body && typeof body === 'object' && 'message' in body && typeof body.message === 'string'
+        ? body.message
+        : null) ??
+      res.statusText ??
+      `HTTP ${res.status}`
+    throw new ApiError(res.status, message, body)
   }
   if ([204, 205, 304].includes(res.status)) {
     return undefined as T

ui/lib/api/jobs/jobs.ts

@@ -1,362 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useMutation, useQuery } from '@tanstack/react-query'
-import type {
-  DataTag,
-  DefinedInitialDataOptions,
-  DefinedUseQueryResult,
-  MutationFunction,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  UndefinedInitialDataOptions,
-  UseMutationOptions,
-  UseMutationResult,
-  UseQueryOptions,
-  UseQueryResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type { ApiError, JobState, PipelineJobRequest } from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getListJobsUrl = () => {
-  return `/api/v1/jobs`
-}
-
-export const listJobs = async (options?: RequestInit): Promise<JobState[]> => {
-  return fetchApi<JobState[]>(getListJobsUrl(), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getListJobsQueryKey = () => {
-  return [`/api/v1/jobs`] as const
-}
-
-export const getListJobsQueryOptions = <
-  TData = Awaited<ReturnType<typeof listJobs>>,
-  TError = unknown,
->(options?: {
-  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listJobs>>, TError, TData>>
-  request?: SecondParameter<typeof fetchApi>
-}) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getListJobsQueryKey()
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof listJobs>>> = ({ signal }) =>
-    listJobs({ signal, ...requestOptions })
-
-  return { queryKey, queryFn, gcTime: 300000, retry: 1, ...queryOptions } as UseQueryOptions<
-    Awaited<ReturnType<typeof listJobs>>,
-    TError,
-    TData
-  > & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type ListJobsQueryResult = NonNullable<Awaited<ReturnType<typeof listJobs>>>
-export type ListJobsQueryError = unknown
-
-export function useListJobs<TData = Awaited<ReturnType<typeof listJobs>>, TError = unknown>(
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof listJobs>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof listJobs>>,
-          TError,
-          Awaited<ReturnType<typeof listJobs>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useListJobs<TData = Awaited<ReturnType<typeof listJobs>>, TError = unknown>(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listJobs>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof listJobs>>,
-          TError,
-          Awaited<ReturnType<typeof listJobs>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useListJobs<TData = Awaited<ReturnType<typeof listJobs>>, TError = unknown>(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listJobs>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useListJobs<TData = Awaited<ReturnType<typeof listJobs>>, TError = unknown>(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof listJobs>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getListJobsQueryOptions(options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}
-
-export const getStartPipelineUrl = () => {
-  return `/api/v1/jobs/pipeline`
-}
-
-export const startPipeline = async (
-  pipelineJobRequest: PipelineJobRequest,
-  options?: RequestInit,
-): Promise<JobState> => {
-  return fetchApi<JobState>(getStartPipelineUrl(), {
-    ...options,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(pipelineJobRequest),
-  })
-}
-
-export const getStartPipelineMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof startPipeline>>,
-    TError,
-    { data: PipelineJobRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof startPipeline>>,
-  TError,
-  { data: PipelineJobRequest },
-  TContext
-> => {
-  const mutationKey = ['startPipeline']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof startPipeline>>,
-    { data: PipelineJobRequest }
-  > = (props) => {
-    const { data } = props ?? {}
-
-    return startPipeline(data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type StartPipelineMutationResult = NonNullable<Awaited<ReturnType<typeof startPipeline>>>
-export type StartPipelineMutationBody = PipelineJobRequest
-export type StartPipelineMutationError = ApiError
-
-export const useStartPipeline = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof startPipeline>>,
-      TError,
-      { data: PipelineJobRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof startPipeline>>,
-  TError,
-  { data: PipelineJobRequest },
-  TContext
-> => {
-  return useMutation(getStartPipelineMutationOptions(options), queryClient)
-}
-export const getGetJobUrl = (jobId: string) => {
-  return `/api/v1/jobs/${jobId}`
-}
-
-export const getJob = async (jobId: string, options?: RequestInit): Promise<JobState> => {
-  return fetchApi<JobState>(getGetJobUrl(jobId), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getGetJobQueryKey = (jobId: string) => {
-  return [`/api/v1/jobs/${jobId}`] as const
-}
-
-export const getGetJobQueryOptions = <
-  TData = Awaited<ReturnType<typeof getJob>>,
-  TError = ApiError,
->(
-  jobId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getJob>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getGetJobQueryKey(jobId)
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof getJob>>> = ({ signal }) =>
-    getJob(jobId, { signal, ...requestOptions })
-
-  return {
-    queryKey,
-    queryFn,
-    enabled: !!jobId,
-    gcTime: 300000,
-    retry: 1,
-    ...queryOptions,
-  } as UseQueryOptions<Awaited<ReturnType<typeof getJob>>, TError, TData> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-}
-
-export type GetJobQueryResult = NonNullable<Awaited<ReturnType<typeof getJob>>>
-export type GetJobQueryError = ApiError
-
-export function useGetJob<TData = Awaited<ReturnType<typeof getJob>>, TError = ApiError>(
-  jobId: string,
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getJob>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getJob>>,
-          TError,
-          Awaited<ReturnType<typeof getJob>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetJob<TData = Awaited<ReturnType<typeof getJob>>, TError = ApiError>(
-  jobId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getJob>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getJob>>,
-          TError,
-          Awaited<ReturnType<typeof getJob>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetJob<TData = Awaited<ReturnType<typeof getJob>>, TError = ApiError>(
-  jobId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getJob>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useGetJob<TData = Awaited<ReturnType<typeof getJob>>, TError = ApiError>(
-  jobId: string,
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getJob>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getGetJobQueryOptions(jobId, options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}
-
-export const getCancelJobUrl = (jobId: string) => {
-  return `/api/v1/jobs/${jobId}`
-}
-
-export const cancelJob = async (jobId: string, options?: RequestInit): Promise<void> => {
-  return fetchApi<void>(getCancelJobUrl(jobId), {
-    ...options,
-    method: 'DELETE',
-  })
-}
-
-export const getCancelJobMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof cancelJob>>,
-    TError,
-    { jobId: string },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof cancelJob>>,
-  TError,
-  { jobId: string },
-  TContext
-> => {
-  const mutationKey = ['cancelJob']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<Awaited<ReturnType<typeof cancelJob>>, { jobId: string }> = (
-    props,
-  ) => {
-    const { jobId } = props ?? {}
-
-    return cancelJob(jobId, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type CancelJobMutationResult = NonNullable<Awaited<ReturnType<typeof cancelJob>>>
-
-export type CancelJobMutationError = ApiError
-
-export const useCancelJob = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof cancelJob>>,
-      TError,
-      { jobId: string },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof cancelJob>>,
-  TError,
-  { jobId: string },
-  TContext
-> => {
-  return useMutation(getCancelJobMutationOptions(options), queryClient)
-}

ui/lib/api/llm/llm.ts

@@ -1,337 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useMutation, useQuery } from '@tanstack/react-query'
-import type {
-  DataTag,
-  DefinedInitialDataOptions,
-  DefinedUseQueryResult,
-  MutationFunction,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  UndefinedInitialDataOptions,
-  UseMutationOptions,
-  UseMutationResult,
-  UseQueryOptions,
-  UseQueryResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type { ApiError, LlmCatalog, LlmLoadRequest, LlmState } from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getGetLlmUrl = () => {
-  return `/api/v1/llm`
-}
-
-export const getLlm = async (options?: RequestInit): Promise<LlmState> => {
-  return fetchApi<LlmState>(getGetLlmUrl(), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getGetLlmQueryKey = () => {
-  return [`/api/v1/llm`] as const
-}
-
-export const getGetLlmQueryOptions = <
-  TData = Awaited<ReturnType<typeof getLlm>>,
-  TError = ApiError,
->(options?: {
-  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlm>>, TError, TData>>
-  request?: SecondParameter<typeof fetchApi>
-}) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getGetLlmQueryKey()
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof getLlm>>> = ({ signal }) =>
-    getLlm({ signal, ...requestOptions })
-
-  return { queryKey, queryFn, gcTime: 300000, retry: 1, ...queryOptions } as UseQueryOptions<
-    Awaited<ReturnType<typeof getLlm>>,
-    TError,
-    TData
-  > & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type GetLlmQueryResult = NonNullable<Awaited<ReturnType<typeof getLlm>>>
-export type GetLlmQueryError = ApiError
-
-export function useGetLlm<TData = Awaited<ReturnType<typeof getLlm>>, TError = ApiError>(
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlm>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getLlm>>,
-          TError,
-          Awaited<ReturnType<typeof getLlm>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetLlm<TData = Awaited<ReturnType<typeof getLlm>>, TError = ApiError>(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlm>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getLlm>>,
-          TError,
-          Awaited<ReturnType<typeof getLlm>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetLlm<TData = Awaited<ReturnType<typeof getLlm>>, TError = ApiError>(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlm>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useGetLlm<TData = Awaited<ReturnType<typeof getLlm>>, TError = ApiError>(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlm>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getGetLlmQueryOptions(options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}
-
-export const getLoadLlmUrl = () => {
-  return `/api/v1/llm`
-}
-
-export const loadLlm = async (
-  llmLoadRequest: LlmLoadRequest,
-  options?: RequestInit,
-): Promise<LlmState> => {
-  return fetchApi<LlmState>(getLoadLlmUrl(), {
-    ...options,
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(llmLoadRequest),
-  })
-}
-
-export const getLoadLlmMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof loadLlm>>,
-    TError,
-    { data: LlmLoadRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof loadLlm>>,
-  TError,
-  { data: LlmLoadRequest },
-  TContext
-> => {
-  const mutationKey = ['loadLlm']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof loadLlm>>,
-    { data: LlmLoadRequest }
-  > = (props) => {
-    const { data } = props ?? {}
-
-    return loadLlm(data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type LoadLlmMutationResult = NonNullable<Awaited<ReturnType<typeof loadLlm>>>
-export type LoadLlmMutationBody = LlmLoadRequest
-export type LoadLlmMutationError = ApiError
-
-export const useLoadLlm = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof loadLlm>>,
-      TError,
-      { data: LlmLoadRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof loadLlm>>,
-  TError,
-  { data: LlmLoadRequest },
-  TContext
-> => {
-  return useMutation(getLoadLlmMutationOptions(options), queryClient)
-}
-export const getUnloadLlmUrl = () => {
-  return `/api/v1/llm`
-}
-
-export const unloadLlm = async (options?: RequestInit): Promise<LlmState> => {
-  return fetchApi<LlmState>(getUnloadLlmUrl(), {
-    ...options,
-    method: 'DELETE',
-  })
-}
-
-export const getUnloadLlmMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<Awaited<ReturnType<typeof unloadLlm>>, TError, void, TContext>
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<Awaited<ReturnType<typeof unloadLlm>>, TError, void, TContext> => {
-  const mutationKey = ['unloadLlm']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<Awaited<ReturnType<typeof unloadLlm>>, void> = () => {
-    return unloadLlm(requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type UnloadLlmMutationResult = NonNullable<Awaited<ReturnType<typeof unloadLlm>>>
-
-export type UnloadLlmMutationError = ApiError
-
-export const useUnloadLlm = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<Awaited<ReturnType<typeof unloadLlm>>, TError, void, TContext>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<Awaited<ReturnType<typeof unloadLlm>>, TError, void, TContext> => {
-  return useMutation(getUnloadLlmMutationOptions(options), queryClient)
-}
-export const getGetLlmCatalogUrl = () => {
-  return `/api/v1/llm/catalog`
-}
-
-export const getLlmCatalog = async (options?: RequestInit): Promise<LlmCatalog> => {
-  return fetchApi<LlmCatalog>(getGetLlmCatalogUrl(), {
-    ...options,
-    method: 'GET',
-  })
-}
-
-export const getGetLlmCatalogQueryKey = () => {
-  return [`/api/v1/llm/catalog`] as const
-}
-
-export const getGetLlmCatalogQueryOptions = <
-  TData = Awaited<ReturnType<typeof getLlmCatalog>>,
-  TError = ApiError,
->(options?: {
-  query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlmCatalog>>, TError, TData>>
-  request?: SecondParameter<typeof fetchApi>
-}) => {
-  const { query: queryOptions, request: requestOptions } = options ?? {}
-
-  const queryKey = queryOptions?.queryKey ?? getGetLlmCatalogQueryKey()
-
-  const queryFn: QueryFunction<Awaited<ReturnType<typeof getLlmCatalog>>> = ({ signal }) =>
-    getLlmCatalog({ signal, ...requestOptions })
-
-  return { queryKey, queryFn, gcTime: 300000, retry: 1, ...queryOptions } as UseQueryOptions<
-    Awaited<ReturnType<typeof getLlmCatalog>>,
-    TError,
-    TData
-  > & { queryKey: DataTag<QueryKey, TData, TError> }
-}
-
-export type GetLlmCatalogQueryResult = NonNullable<Awaited<ReturnType<typeof getLlmCatalog>>>
-export type GetLlmCatalogQueryError = ApiError
-
-export function useGetLlmCatalog<
-  TData = Awaited<ReturnType<typeof getLlmCatalog>>,
-  TError = ApiError,
->(
-  options: {
-    query: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlmCatalog>>, TError, TData>> &
-      Pick<
-        DefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getLlmCatalog>>,
-          TError,
-          Awaited<ReturnType<typeof getLlmCatalog>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): DefinedUseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetLlmCatalog<
-  TData = Awaited<ReturnType<typeof getLlmCatalog>>,
-  TError = ApiError,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlmCatalog>>, TError, TData>> &
-      Pick<
-        UndefinedInitialDataOptions<
-          Awaited<ReturnType<typeof getLlmCatalog>>,
-          TError,
-          Awaited<ReturnType<typeof getLlmCatalog>>
-        >,
-        'initialData'
-      >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-export function useGetLlmCatalog<
-  TData = Awaited<ReturnType<typeof getLlmCatalog>>,
-  TError = ApiError,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlmCatalog>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> }
-
-export function useGetLlmCatalog<
-  TData = Awaited<ReturnType<typeof getLlmCatalog>>,
-  TError = ApiError,
->(
-  options?: {
-    query?: Partial<UseQueryOptions<Awaited<ReturnType<typeof getLlmCatalog>>, TError, TData>>
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseQueryResult<TData, TError> & { queryKey: DataTag<QueryKey, TData, TError> } {
-  const queryOptions = getGetLlmCatalogQueryOptions(options)
-
-  const query = useQuery(queryOptions, queryClient) as UseQueryResult<TData, TError> & {
-    queryKey: DataTag<QueryKey, TData, TError>
-  }
-
-  return { ...query, queryKey: queryOptions.queryKey }
-}

ui/lib/api/processing/processing.ts

@@ -1,378 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useMutation } from '@tanstack/react-query'
-import type {
-  MutationFunction,
-  QueryClient,
-  UseMutationOptions,
-  UseMutationResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type { ApiError, RenderRequest, TranslateRequest } from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getDetectDocumentUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/detect`
-}
-
-export const detectDocument = async (documentId: string, options?: RequestInit): Promise<void> => {
-  return fetchApi<void>(getDetectDocumentUrl(documentId), {
-    ...options,
-    method: 'POST',
-  })
-}
-
-export const getDetectDocumentMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof detectDocument>>,
-    TError,
-    { documentId: string },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof detectDocument>>,
-  TError,
-  { documentId: string },
-  TContext
-> => {
-  const mutationKey = ['detectDocument']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof detectDocument>>,
-    { documentId: string }
-  > = (props) => {
-    const { documentId } = props ?? {}
-
-    return detectDocument(documentId, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type DetectDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof detectDocument>>>
-
-export type DetectDocumentMutationError = ApiError
-
-export const useDetectDocument = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof detectDocument>>,
-      TError,
-      { documentId: string },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof detectDocument>>,
-  TError,
-  { documentId: string },
-  TContext
-> => {
-  return useMutation(getDetectDocumentMutationOptions(options), queryClient)
-}
-export const getInpaintDocumentUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/inpaint`
-}
-
-export const inpaintDocument = async (documentId: string, options?: RequestInit): Promise<void> => {
-  return fetchApi<void>(getInpaintDocumentUrl(documentId), {
-    ...options,
-    method: 'POST',
-  })
-}
-
-export const getInpaintDocumentMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof inpaintDocument>>,
-    TError,
-    { documentId: string },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof inpaintDocument>>,
-  TError,
-  { documentId: string },
-  TContext
-> => {
-  const mutationKey = ['inpaintDocument']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof inpaintDocument>>,
-    { documentId: string }
-  > = (props) => {
-    const { documentId } = props ?? {}
-
-    return inpaintDocument(documentId, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type InpaintDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof inpaintDocument>>>
-
-export type InpaintDocumentMutationError = ApiError
-
-export const useInpaintDocument = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof inpaintDocument>>,
-      TError,
-      { documentId: string },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof inpaintDocument>>,
-  TError,
-  { documentId: string },
-  TContext
-> => {
-  return useMutation(getInpaintDocumentMutationOptions(options), queryClient)
-}
-export const getRecognizeDocumentUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/recognize`
-}
-
-export const recognizeDocument = async (
-  documentId: string,
-  options?: RequestInit,
-): Promise<void> => {
-  return fetchApi<void>(getRecognizeDocumentUrl(documentId), {
-    ...options,
-    method: 'POST',
-  })
-}
-
-export const getRecognizeDocumentMutationOptions = <
-  TError = ApiError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof recognizeDocument>>,
-    TError,
-    { documentId: string },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof recognizeDocument>>,
-  TError,
-  { documentId: string },
-  TContext
-> => {
-  const mutationKey = ['recognizeDocument']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof recognizeDocument>>,
-    { documentId: string }
-  > = (props) => {
-    const { documentId } = props ?? {}
-
-    return recognizeDocument(documentId, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type RecognizeDocumentMutationResult = NonNullable<
-  Awaited<ReturnType<typeof recognizeDocument>>
->
-
-export type RecognizeDocumentMutationError = ApiError
-
-export const useRecognizeDocument = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof recognizeDocument>>,
-      TError,
-      { documentId: string },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof recognizeDocument>>,
-  TError,
-  { documentId: string },
-  TContext
-> => {
-  return useMutation(getRecognizeDocumentMutationOptions(options), queryClient)
-}
-export const getRenderDocumentUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/render`
-}
-
-export const renderDocument = async (
-  documentId: string,
-  renderRequest: RenderRequest,
-  options?: RequestInit,
-): Promise<void> => {
-  return fetchApi<void>(getRenderDocumentUrl(documentId), {
-    ...options,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(renderRequest),
-  })
-}
-
-export const getRenderDocumentMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof renderDocument>>,
-    TError,
-    { documentId: string; data: RenderRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof renderDocument>>,
-  TError,
-  { documentId: string; data: RenderRequest },
-  TContext
-> => {
-  const mutationKey = ['renderDocument']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof renderDocument>>,
-    { documentId: string; data: RenderRequest }
-  > = (props) => {
-    const { documentId, data } = props ?? {}
-
-    return renderDocument(documentId, data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type RenderDocumentMutationResult = NonNullable<Awaited<ReturnType<typeof renderDocument>>>
-export type RenderDocumentMutationBody = RenderRequest
-export type RenderDocumentMutationError = ApiError
-
-export const useRenderDocument = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof renderDocument>>,
-      TError,
-      { documentId: string; data: RenderRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof renderDocument>>,
-  TError,
-  { documentId: string; data: RenderRequest },
-  TContext
-> => {
-  return useMutation(getRenderDocumentMutationOptions(options), queryClient)
-}
-export const getTranslateDocumentUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/translate`
-}
-
-export const translateDocument = async (
-  documentId: string,
-  translateRequest: TranslateRequest,
-  options?: RequestInit,
-): Promise<void> => {
-  return fetchApi<void>(getTranslateDocumentUrl(documentId), {
-    ...options,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(translateRequest),
-  })
-}
-
-export const getTranslateDocumentMutationOptions = <
-  TError = ApiError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof translateDocument>>,
-    TError,
-    { documentId: string; data: TranslateRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof translateDocument>>,
-  TError,
-  { documentId: string; data: TranslateRequest },
-  TContext
-> => {
-  const mutationKey = ['translateDocument']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof translateDocument>>,
-    { documentId: string; data: TranslateRequest }
-  > = (props) => {
-    const { documentId, data } = props ?? {}
-
-    return translateDocument(documentId, data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type TranslateDocumentMutationResult = NonNullable<
-  Awaited<ReturnType<typeof translateDocument>>
->
-export type TranslateDocumentMutationBody = TranslateRequest
-export type TranslateDocumentMutationError = ApiError
-
-export const useTranslateDocument = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof translateDocument>>,
-      TError,
-      { documentId: string; data: TranslateRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof translateDocument>>,
-  TError,
-  { documentId: string; data: TranslateRequest },
-  TContext
-> => {
-  return useMutation(getTranslateDocumentMutationOptions(options), queryClient)
-}

ui/lib/api/regions/regions.ts

@@ -1,247 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import { useMutation } from '@tanstack/react-query'
-import type {
-  MutationFunction,
-  QueryClient,
-  UseMutationOptions,
-  UseMutationResult,
-} from '@tanstack/react-query'
-
-import { fetchApi } from '.././fetch'
-import type {
-  ApiError,
-  BrushRegionRequest,
-  InpaintRegionRequest,
-  MaskRegionRequest,
-} from '../schemas'
-
-type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1]
-
-export const getUpdateBrushLayerUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/brush-layer`
-}
-
-export const updateBrushLayer = async (
-  documentId: string,
-  brushRegionRequest: BrushRegionRequest,
-  options?: RequestInit,
-): Promise<void> => {
-  return fetchApi<void>(getUpdateBrushLayerUrl(documentId), {
-    ...options,
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(brushRegionRequest),
-  })
-}
-
-export const getUpdateBrushLayerMutationOptions = <
-  TError = ApiError,
-  TContext = unknown,
->(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof updateBrushLayer>>,
-    TError,
-    { documentId: string; data: BrushRegionRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof updateBrushLayer>>,
-  TError,
-  { documentId: string; data: BrushRegionRequest },
-  TContext
-> => {
-  const mutationKey = ['updateBrushLayer']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof updateBrushLayer>>,
-    { documentId: string; data: BrushRegionRequest }
-  > = (props) => {
-    const { documentId, data } = props ?? {}
-
-    return updateBrushLayer(documentId, data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type UpdateBrushLayerMutationResult = NonNullable<
-  Awaited<ReturnType<typeof updateBrushLayer>>
->
-export type UpdateBrushLayerMutationBody = BrushRegionRequest
-export type UpdateBrushLayerMutationError = ApiError
-
-export const useUpdateBrushLayer = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof updateBrushLayer>>,
-      TError,
-      { documentId: string; data: BrushRegionRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof updateBrushLayer>>,
-  TError,
-  { documentId: string; data: BrushRegionRequest },
-  TContext
-> => {
-  return useMutation(getUpdateBrushLayerMutationOptions(options), queryClient)
-}
-export const getInpaintRegionUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/inpaint-region`
-}
-
-export const inpaintRegion = async (
-  documentId: string,
-  inpaintRegionRequest: InpaintRegionRequest,
-  options?: RequestInit,
-): Promise<void> => {
-  return fetchApi<void>(getInpaintRegionUrl(documentId), {
-    ...options,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(inpaintRegionRequest),
-  })
-}
-
-export const getInpaintRegionMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof inpaintRegion>>,
-    TError,
-    { documentId: string; data: InpaintRegionRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof inpaintRegion>>,
-  TError,
-  { documentId: string; data: InpaintRegionRequest },
-  TContext
-> => {
-  const mutationKey = ['inpaintRegion']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof inpaintRegion>>,
-    { documentId: string; data: InpaintRegionRequest }
-  > = (props) => {
-    const { documentId, data } = props ?? {}
-
-    return inpaintRegion(documentId, data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type InpaintRegionMutationResult = NonNullable<Awaited<ReturnType<typeof inpaintRegion>>>
-export type InpaintRegionMutationBody = InpaintRegionRequest
-export type InpaintRegionMutationError = ApiError
-
-export const useInpaintRegion = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof inpaintRegion>>,
-      TError,
-      { documentId: string; data: InpaintRegionRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof inpaintRegion>>,
-  TError,
-  { documentId: string; data: InpaintRegionRequest },
-  TContext
-> => {
-  return useMutation(getInpaintRegionMutationOptions(options), queryClient)
-}
-export const getUpdateMaskUrl = (documentId: string) => {
-  return `/api/v1/documents/${documentId}/mask`
-}
-
-export const updateMask = async (
-  documentId: string,
-  maskRegionRequest: MaskRegionRequest,
-  options?: RequestInit,
-): Promise<void> => {
-  return fetchApi<void>(getUpdateMaskUrl(documentId), {
-    ...options,
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json', ...options?.headers },
-    body: JSON.stringify(maskRegionRequest),
-  })
-}
-
-export const getUpdateMaskMutationOptions = <TError = ApiError, TContext = unknown>(options?: {
-  mutation?: UseMutationOptions<
-    Awaited<ReturnType<typeof updateMask>>,
-    TError,
-    { documentId: string; data: MaskRegionRequest },
-    TContext
-  >
-  request?: SecondParameter<typeof fetchApi>
-}): UseMutationOptions<
-  Awaited<ReturnType<typeof updateMask>>,
-  TError,
-  { documentId: string; data: MaskRegionRequest },
-  TContext
-> => {
-  const mutationKey = ['updateMask']
-  const { mutation: mutationOptions, request: requestOptions } = options
-    ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey
-      ? options
-      : { ...options, mutation: { ...options.mutation, mutationKey } }
-    : { mutation: { mutationKey }, request: undefined }
-
-  const mutationFn: MutationFunction<
-    Awaited<ReturnType<typeof updateMask>>,
-    { documentId: string; data: MaskRegionRequest }
-  > = (props) => {
-    const { documentId, data } = props ?? {}
-
-    return updateMask(documentId, data, requestOptions)
-  }
-
-  return { mutationFn, ...mutationOptions }
-}
-
-export type UpdateMaskMutationResult = NonNullable<Awaited<ReturnType<typeof updateMask>>>
-export type UpdateMaskMutationBody = MaskRegionRequest
-export type UpdateMaskMutationError = ApiError
-
-export const useUpdateMask = <TError = ApiError, TContext = unknown>(
-  options?: {
-    mutation?: UseMutationOptions<
-      Awaited<ReturnType<typeof updateMask>>,
-      TError,
-      { documentId: string; data: MaskRegionRequest },
-      TContext
-    >
-    request?: SecondParameter<typeof fetchApi>
-  },
-  queryClient?: QueryClient,
-): UseMutationResult<
-  Awaited<ReturnType<typeof updateMask>>,
-  TError,
-  { documentId: string; data: MaskRegionRequest },
-  TContext
-> => {
-  return useMutation(getUpdateMaskMutationOptions(options), queryClient)
-}

ui/lib/api/schemas/addImageLayerResponse.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { NodeId } from './nodeId'
+
+export interface AddImageLayerResponse {
+  node: NodeId
+}

ui/lib/api/schemas/{getConfig200.ts → appConfig.ts}

@@ -8,7 +8,7 @@ import type { HttpConfig } from './httpConfig'
 import type { PipelineConfig } from './pipelineConfig'
 import type { ProviderConfig } from './providerConfig'
 
-export type GetConfig200 = {
+export interface AppConfig {
   data?: DataConfig
   http?: HttpConfig
   pipeline?: PipelineConfig

ui/lib/api/schemas/appEvent.ts

@@ -0,0 +1,44 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { DownloadProgress } from './downloadProgress'
+import type { JobFinishedEvent } from './jobFinishedEvent'
+import type { LlmTarget } from './llmTarget'
+import type { PipelineProgress } from './pipelineProgress'
+import type { SnapshotEvent } from './snapshotEvent'
+
+export type AppEvent =
+  | {
+      event: 'jobStarted'
+      id: string
+      kind: string
+    }
+  | (PipelineProgress & {
+      event: 'jobProgress'
+    })
+  | (JobFinishedEvent & {
+      event: 'jobFinished'
+    })
+  | (DownloadProgress & {
+      event: 'downloadProgress'
+    })
+  | {
+      event: 'llmLoading'
+      target: LlmTarget
+    }
+  | {
+      event: 'llmLoaded'
+      target: LlmTarget
+    }
+  | {
+      event: 'llmFailed'
+      target?: null | LlmTarget
+    }
+  | {
+      event: 'llmUnloaded'
+    }
+  | (SnapshotEvent & {
+      event: 'snapshot'
+    })

ui/lib/api/schemas/blobRef.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+/**
+ * Hex-encoded blake3 hash of an immutable blob.
+ */
+export type BlobRef = string

ui/lib/api/schemas/configPatch.ts

@@ -0,0 +1,26 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { DataConfigPatch } from './dataConfigPatch'
+import type { HttpConfigPatch } from './httpConfigPatch'
+import type { PipelineConfigPatch } from './pipelineConfigPatch'
+import type { ProviderPatch } from './providerPatch'
+
+/**
+ * Sparse patch for `koharu_app::AppConfig`. Missing fields mean "leave
+as-is". The `providers` field, if present, replaces the whole provider
+list — we do not merge by id because ordering is meaningful.
+ */
+export interface ConfigPatch {
+  data?: null | DataConfigPatch
+  http?: null | HttpConfigPatch
+  pipeline?: null | PipelineConfigPatch
+  /**
+     * If present, replaces the entire list. Api_key values of `"[REDACTED]"`
+  are interpreted as "leave the existing secret alone".
+     * @nullable
+     */
+  providers?: ProviderPatch[] | null
+}

ui/lib/api/schemas/createPagesFromPathsRequest.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export interface CreatePagesFromPathsRequest {
+  paths: string[]
+  replace?: boolean
+}

ui/lib/api/schemas/createPagesResponse.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { PageId } from './pageId'
+
+export interface CreatePagesResponse {
+  pages: PageId[]
+}

ui/lib/api/schemas/{importDocumentsBody.ts → createProjectRequest.ts}

@@ -4,6 +4,6 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export type ImportDocumentsBody = {
-  files: Blob[]
+export interface CreateProjectRequest {
+  name: string
 }

ui/lib/api/schemas/{updateDocumentStyleRequest.ts → dataConfigPatch.ts}

@@ -4,7 +4,7 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export interface UpdateDocumentStyleRequest {
+export interface DataConfigPatch {
   /** @nullable */
-  defaultFont?: string | null
+  path?: string | null
 }

ui/lib/api/schemas/documentDetail.ts

@@ -1,40 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import type { DocumentStyle } from './documentStyle'
-import type { TextBlockDetail } from './textBlockDetail'
-
-export interface DocumentDetail {
-  /**
-   * Blob hash for the brush layer.
-   * @nullable
-   */
-  brushLayer?: string | null
-  /** @minimum 0 */
-  height: number
-  id: string
-  /** Blob hash for the source image layer. */
-  image: string
-  /**
-   * Blob hash for the inpainted layer.
-   * @nullable
-   */
-  inpainted?: string | null
-  name: string
-  /**
-   * Blob hash for the rendered composite layer.
-   * @nullable
-   */
-  rendered?: string | null
-  /**
-   * Blob hash for the segmentation mask layer.
-   * @nullable
-   */
-  segment?: string | null
-  style?: null | DocumentStyle
-  textBlocks: TextBlockDetail[]
-  /** @minimum 0 */
-  width: number
-}

ui/lib/api/schemas/{downloadState.ts → downloadProgress.ts}

@@ -3,16 +3,14 @@
  * Do not edit manually.
  * OpenAPI spec version: 0.0.1
  */
-import type { TransferStatus } from './transferStatus'
+import type { DownloadStatus } from './downloadStatus'
 
-export interface DownloadState {
+export interface DownloadProgress {
   /** @minimum 0 */
   downloaded: number
-  /** @nullable */
-  error?: string | null
   filename: string
   id: string
-  status: TransferStatus
+  status: DownloadStatus
   /**
    * @minimum 0
    * @nullable

ui/lib/api/schemas/downloadStatus.ts

@@ -0,0 +1,20 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export type DownloadStatus =
+  | {
+      status: 'started'
+    }
+  | {
+      status: 'downloading'
+    }
+  | {
+      status: 'completed'
+    }
+  | {
+      reason: string
+      status: 'failed'
+    }

ui/lib/api/schemas/{getEngineCatalog200.ts → engineCatalog.ts}

@@ -5,7 +5,8 @@
  */
 import type { EngineCatalogEntry } from './engineCatalogEntry'
 
-export type GetEngineCatalog200 = {
+export interface EngineCatalog {
+  bubbleSegmenters: EngineCatalogEntry[]
   detectors: EngineCatalogEntry[]
   fontDetectors: EngineCatalogEntry[]
   inpainters: EngineCatalogEntry[]

ui/lib/api/schemas/{apiError.ts → errorEvent.ts}

@@ -4,8 +4,7 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export interface ApiError {
+export interface ErrorEvent {
   message: string
-  /** @minimum 0 */
-  status: number
+  scope: string
 }

ui/lib/api/schemas/exportBatchRequest.ts

@@ -1,10 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import type { ExportLayer } from './exportLayer'
-
-export interface ExportBatchRequest {
-  layer?: null | ExportLayer
-}

ui/lib/api/schemas/exportDocumentParams.ts

@@ -1,10 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import type { ExportLayer } from './exportLayer'
-
-export type ExportDocumentParams = {
-  layer?: null | ExportLayer
-}

ui/lib/api/schemas/{exportLayer.ts → exportFormat.ts}

@@ -4,9 +4,11 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export type ExportLayer = (typeof ExportLayer)[keyof typeof ExportLayer]
+export type ExportFormat = (typeof ExportFormat)[keyof typeof ExportFormat]
 
-export const ExportLayer = {
+export const ExportFormat = {
+  khr: 'khr',
+  psd: 'psd',
   rendered: 'rendered',
   inpainted: 'inpainted',
 } as const

ui/lib/api/schemas/exportProjectRequest.ts

@@ -0,0 +1,16 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { ExportFormat } from './exportFormat'
+import type { PageId } from './pageId'
+
+export interface ExportProjectRequest {
+  format: ExportFormat
+  /**
+   * Optional subset of pages; defaults to every page.
+   * @nullable
+   */
+  pages?: PageId[] | null
+}

ui/lib/api/schemas/fontPrediction.ts

@@ -8,13 +8,13 @@ import type { TextDirection } from './textDirection'
 import type { TopFont } from './topFont'
 
 export interface FontPrediction {
-  angle_deg: number
+  angleDeg: number
   direction: TextDirection
-  font_size_px: number
-  line_height: number
-  named_fonts: NamedFontPrediction[]
-  stroke_color: number[]
-  stroke_width_px: number
-  text_color: number[]
-  top_fonts: TopFont[]
+  fontSizePx: number
+  lineHeight: number
+  namedFonts: NamedFontPrediction[]
+  strokeColor: number[]
+  strokeWidthPx: number
+  textColor: number[]
+  topFonts: TopFont[]
 }

ui/lib/api/schemas/getLlmCatalogParams.ts

@@ -1,12 +0,0 @@
-/**
- * Generated by orval v8.6.2 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-
-export type GetLlmCatalogParams = {
-  /**
-   * @nullable
-   */
-  language?: string | null
-}

ui/lib/api/schemas/googleFontCatalog.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { GoogleFontEntry } from './googleFontEntry'
+
+export interface GoogleFontCatalog {
+  fonts: GoogleFontEntry[]
+}

ui/lib/api/schemas/googleFontCatalogResponse.ts

@@ -1,11 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import type { GoogleFontCatalogEntry } from './googleFontCatalogEntry'
-
-export interface GoogleFontCatalogResponse {
-  fonts: GoogleFontCatalogEntry[]
-  recommended: string[]
-}

ui/lib/api/schemas/{googleFontCatalogEntry.ts → googleFontEntry.ts}

@@ -3,10 +3,11 @@
  * Do not edit manually.
  * OpenAPI spec version: 0.0.1
  */
+import type { GoogleFontVariant } from './googleFontVariant'
 
-export interface GoogleFontCatalogEntry {
-  cached: boolean
+export interface GoogleFontEntry {
   category: string
   family: string
   subsets: string[]
+  variants: GoogleFontVariant[]
 }

ui/lib/api/schemas/googleFontVariant.ts

@@ -0,0 +1,12 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export interface GoogleFontVariant {
+  filename: string
+  style: string
+  /** @minimum 0 */
+  weight: number
+}

ui/lib/api/schemas/{getDocumentThumbnailParams.ts → historyResult.ts}

@@ -4,10 +4,11 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export type GetDocumentThumbnailParams = {
+export interface HistoryResult {
   /**
+   * New epoch. `None` only for a no-op undo/redo at the stack boundary.
    * @minimum 0
    * @nullable
    */
-  size?: number | null
+  epoch?: number | null
 }

ui/lib/api/schemas/httpConfigPatch.ts

@@ -0,0 +1,23 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export interface HttpConfigPatch {
+  /**
+   * @minimum 0
+   * @nullable
+   */
+  connectTimeout?: number | null
+  /**
+   * @minimum 0
+   * @nullable
+   */
+  maxRetries?: number | null
+  /**
+   * @minimum 0
+   * @nullable
+   */
+  readTimeout?: number | null
+}

ui/lib/api/schemas/imageData.ts

@@ -0,0 +1,21 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { BlobRef } from './blobRef'
+import type { ImageRole } from './imageRole'
+
+export interface ImageData {
+  blob: BlobRef
+  /** @nullable */
+  name?: string | null
+  /** @minimum 0 */
+  naturalHeight: number
+  /** @minimum 0 */
+  naturalWidth: number
+  opacity?: number
+  /** Role tags differentiate source / inpainted / rendered / user-imported images.
+  Role is immutable on an existing node — switching roles = delete + add. */
+  role: ImageRole
+}

ui/lib/api/schemas/{textBlockInput.ts → imageDataPatch.ts}

@@ -3,18 +3,22 @@
  * Do not edit manually.
  * OpenAPI spec version: 0.0.1
  */
-import type { TextStyle } from './textStyle'
+import type { BlobRef } from './blobRef'
 
-export interface TextBlockInput {
-  height: number
+export interface ImageDataPatch {
+  blob?: null | BlobRef
   /** @nullable */
-  id?: string | null
-  style?: null | TextStyle
+  name?: string | null
+  /**
+   * @minimum 0
+   * @nullable
+   */
+  naturalHeight?: number | null
+  /**
+   * @minimum 0
+   * @nullable
+   */
+  naturalWidth?: number | null
   /** @nullable */
-  text?: string | null
-  /** @nullable */
-  translation?: string | null
-  width: number
-  x: number
-  y: number
+  opacity?: number | null
 }

ui/lib/api/schemas/{transferStatus.ts → imageRole.ts}

@@ -4,11 +4,11 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export type TransferStatus = (typeof TransferStatus)[keyof typeof TransferStatus]
+export type ImageRole = (typeof ImageRole)[keyof typeof ImageRole]
 
-export const TransferStatus = {
-  started: 'started',
-  downloading: 'downloading',
-  completed: 'completed',
-  failed: 'failed',
+export const ImageRole = {
+  source: 'source',
+  inpainted: 'inpainted',
+  rendered: 'rendered',
+  custom: 'custom',
 } as const

ui/lib/api/schemas/importDocumentsParams.ts

@@ -1,10 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import type { ImportMode } from './importMode'
-
-export type ImportDocumentsParams = {
-  mode?: null | ImportMode
-}

ui/lib/api/schemas/importProjectParams.ts

@@ -0,0 +1,16 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+
+export type ImportProjectParams = {
+  /**
+ * Optional absolute destination path for the extracted `.khrproj/`
+directory. When omitted, the server allocates a directory under
+`{data.path}/projects/` using a timestamp-and-random suffix. Must not
+already exist when provided.
+ * @nullable
+ */
+  path?: string | null
+}

ui/lib/api/schemas/index.ts

@@ -4,35 +4,40 @@
  * OpenAPI spec version: 0.0.1
  */
 
-export * from './apiError'
-export * from './brushRegionRequest'
-export * from './createTextBlock'
+export * from './addImageLayerResponse'
+export * from './appConfig'
+export * from './appEvent'
+export * from './blobRef'
+export * from './configPatch'
+export * from './createPagesFromPathsRequest'
+export * from './createPagesResponse'
+export * from './createProjectRequest'
 export * from './dataConfig'
-export * from './documentDetail'
-export * from './documentStyle'
-export * from './documentSummary'
-export * from './downloadState'
+export * from './dataConfigPatch'
+export * from './downloadProgress'
+export * from './downloadStatus'
+export * from './engineCatalog'
 export * from './engineCatalogEntry'
-export * from './exportBatchRequest'
-export * from './exportDocumentParams'
-export * from './exportLayer'
-export * from './exportResult'
+export * from './exportFormat'
+export * from './exportProjectRequest'
 export * from './fontFaceInfo'
 export * from './fontPrediction'
 export * from './fontSource'
-export * from './getConfig200'
-export * from './getDocumentThumbnailParams'
-export * from './getEngineCatalog200'
-export * from './googleFontCatalogEntry'
-export * from './googleFontCatalogResponse'
+export * from './googleFontCatalog'
+export * from './googleFontEntry'
+export * from './googleFontVariant'
+export * from './historyResult'
 export * from './httpConfig'
-export * from './importDocumentsBody'
-export * from './importDocumentsParams'
-export * from './importMode'
-export * from './importResult'
-export * from './inpaintRegionRequest'
-export * from './jobState'
+export * from './httpConfigPatch'
+export * from './imageData'
+export * from './imageDataPatch'
+export * from './imageRole'
+export * from './jobFinishedEvent'
 export * from './jobStatus'
+export * from './jobSummary'
+export * from './listDownloadsResponse'
+export * from './listOperationsResponse'
+export * from './listProjectsResponse'
 export * from './llmCatalog'
 export * from './llmCatalogModel'
 export * from './llmGenerationOptions'
@@ -43,27 +48,50 @@ export * from './llmState'
 export * from './llmStateStatus'
 export * from './llmTarget'
 export * from './llmTargetKind'
-export * from './maskRegionRequest'
+export * from './maskData'
+export * from './maskDataPatch'
+export * from './maskRole'
 export * from './metaInfo'
 export * from './namedFontPrediction'
+export * from './node'
+export * from './nodeDataPatch'
+export * from './nodeId'
+export * from './nodeKind'
+export * from './nodePatch'
+export * from './op'
+export * from './openProjectRequest'
+export * from './page'
+export * from './pageId'
+export * from './pageNodes'
+export * from './pagePatch'
 export * from './pipelineConfig'
-export * from './pipelineJobRequest'
-export * from './pipelineLlmRequest'
+export * from './pipelineConfigPatch'
+export * from './pipelineProgress'
+export * from './pipelineStatus'
+export * from './pipelineStep'
+export * from './projectMeta'
+export * from './projectMetaPatch'
+export * from './projectStyle'
+export * from './projectSummary'
 export * from './providerConfig'
+export * from './providerPatch'
+export * from './providerSecretRequest'
+export * from './putMaskResponse'
 export * from './region'
-export * from './renderRequest'
-export * from './reorderRequest'
+export * from './scene'
+export * from './scenePages'
+export * from './sceneSnapshot'
+export * from './snapshotEvent'
+export * from './startDownloadRequest'
+export * from './startDownloadResponse'
+export * from './startPipelineRequest'
+export * from './startPipelineResponse'
 export * from './textAlign'
-export * from './textBlockDetail'
-export * from './textBlockInput'
-export * from './textBlockPatch'
+export * from './textData'
+export * from './textDataPatch'
 export * from './textDirection'
 export * from './textShaderEffect'
 export * from './textStrokeStyle'
 export * from './textStyle'
 export * from './topFont'
-export * from './transferStatus'
-export * from './translateRequest'
-export * from './updateConfig200'
-export * from './updateConfigBody'
-export * from './updateDocumentStyleRequest'
+export * from './transform'

ui/lib/api/schemas/inpaintRegionRequest.ts

@@ -1,10 +0,0 @@
-/**
- * Generated by orval v8.8.0 🍺
- * Do not edit manually.
- * OpenAPI spec version: 0.0.1
- */
-import type { Region } from './region'
-
-export interface InpaintRegionRequest {
-  region: Region
-}

ui/lib/api/schemas/jobFinishedEvent.ts

@@ -0,0 +1,13 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { JobStatus } from './jobStatus'
+
+export interface JobFinishedEvent {
+  /** @nullable */
+  error?: string | null
+  id: string
+  status: JobStatus
+}

ui/lib/api/schemas/jobSummary.ts

@@ -0,0 +1,14 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { JobStatus } from './jobStatus'
+
+export interface JobSummary {
+  /** @nullable */
+  error?: string | null
+  id: string
+  kind: string
+  status: JobStatus
+}

ui/lib/api/schemas/listDownloadsResponse.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { DownloadProgress } from './downloadProgress'
+
+export interface ListDownloadsResponse {
+  downloads: DownloadProgress[]
+}

ui/lib/api/schemas/{brushRegionRequest.ts → listOperationsResponse.ts}

@@ -3,9 +3,8 @@
  * Do not edit manually.
  * OpenAPI spec version: 0.0.1
  */
-import type { Region } from './region'
+import type { JobSummary } from './jobSummary'
 
-export interface BrushRegionRequest {
-  data: number[]
-  region: Region
+export interface ListOperationsResponse {
+  operations: JobSummary[]
 }

ui/lib/api/schemas/listProjectsResponse.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { ProjectSummary } from './projectSummary'
+
+export interface ListProjectsResponse {
+  projects: ProjectSummary[]
+}

ui/lib/api/schemas/maskData.ts

@@ -0,0 +1,12 @@
+/**
+ * Generated by orval v8.8.0 🍺
+ * Do not edit manually.
+ * OpenAPI spec version: 0.0.1
+ */
+import type { BlobRef } from './blobRef'
+import type { MaskRole } from './maskRole'
+
+export interface MaskData {
+  blob: BlobRef
+  role: MaskRole
+}