@webitel/api-services 0.0.92 → 0.0.93

package/src/gen/pdf-service/pdf-service.api.gen.ts

@@ -12,15 +12,13 @@ import type {
 } from 'axios';
 
 import type {
-  DownloadPdfExport200,
-  DownloadPdfExportParams,
-  GetCallPdfHistoryParams,
-  GetScreenrecordingPdfExportHistoryParams,
-  WebitelMediaExporterDeletePdfExportRecordResponse,
-  WebitelMediaExporterPdfExportMetadata,
-  WebitelMediaExporterPdfHistoryResponse,
-  WebitelMediaExporterPdfServiceGenerateCallPdfExportBody,
-  WebitelMediaExporterPdfServiceGenerateScreenrecordingPdfExportBody
+  ListCallExportsParams,
+  ListScreenrecordingExportsParams,
+  WebitelMediaExporterDeleteExportResponse,
+  WebitelMediaExporterExportTask,
+  WebitelMediaExporterListExportsResponse,
+  WebitelMediaExporterPdfServiceCreateCallExportBody,
+  WebitelMediaExporterPdfServiceCreateScreenrecordingExportBody
 } from '.././_models';
 
 
@@ -36,85 +34,75 @@ import type {
 
             // --- header end
           /**
- * @summary Generate a new PDF export asynchronously by Call ID.
+ * @summary Lists the history of PDF exports for a specific agent.
  */
-const generateCallPdfExport = <TData = AxiosResponse<WebitelMediaExporterPdfExportMetadata>>(
-    callId: string,
-    webitelMediaExporterPdfServiceGenerateCallPdfExportBody: WebitelMediaExporterPdfServiceGenerateCallPdfExportBody, options?: AxiosRequestConfig
- ): Promise<TData> => {
-    return axios.post(
-      `/export/pdf/call/${callId}`,
-      webitelMediaExporterPdfServiceGenerateCallPdfExportBody,options
-    );
-  }
-/**
- * @summary Get history of PDF exports for a specific Call.
- */
-const getCallPdfHistory = <TData = AxiosResponse<WebitelMediaExporterPdfHistoryResponse>>(
-    callId: string,
-    params?: GetCallPdfHistoryParams, options?: AxiosRequestConfig
+const listScreenrecordingExports = <TData = AxiosResponse<WebitelMediaExporterListExportsResponse>>(
+    agentId: string,
+    params?: ListScreenrecordingExportsParams, options?: AxiosRequestConfig
  ): Promise<TData> => {
     return axios.get(
-      `/export/pdf/call/${callId}/history`,{
+      `/agents/${agentId}/exports/pdf/screenrecordings`,{
     ...options,
         params: {...params, ...options?.params},}
     );
   }
-const deletePdfExportRecord = <TData = AxiosResponse<WebitelMediaExporterDeletePdfExportRecordResponse>>(
-    id: string, options?: AxiosRequestConfig
- ): Promise<TData> => {
-    return axios.delete(
-      `/export/pdf/history/${id}`,options
-    );
-  }
 /**
- * @summary Generate a new PDF export asynchronously.
-Returns metadata about the created export task.
+ * @summary Creates a new task to generate a PDF export for an agent's screen recordings.
+This operation is asynchronous and returns a task metadata.
  */
-const generateScreenrecordingPdfExport = <TData = AxiosResponse<WebitelMediaExporterPdfExportMetadata>>(
+const createScreenrecordingExport = <TData = AxiosResponse<WebitelMediaExporterExportTask>>(
     agentId: string,
-    webitelMediaExporterPdfServiceGenerateScreenrecordingPdfExportBody: WebitelMediaExporterPdfServiceGenerateScreenrecordingPdfExportBody, options?: AxiosRequestConfig
+    webitelMediaExporterPdfServiceCreateScreenrecordingExportBody: WebitelMediaExporterPdfServiceCreateScreenrecordingExportBody, options?: AxiosRequestConfig
  ): Promise<TData> => {
     return axios.post(
-      `/export/pdf/${agentId}`,
-      webitelMediaExporterPdfServiceGenerateScreenrecordingPdfExportBody,options
+      `/agents/${agentId}/exports/pdf/screenrecordings`,
+      webitelMediaExporterPdfServiceCreateScreenrecordingExportBody,options
     );
   }
 /**
- * @summary Get paginated history of PDF exports for a given agent.
+ * @summary Lists the history of PDF exports for a specific call ID.
  */
-const getScreenrecordingPdfExportHistory = <TData = AxiosResponse<WebitelMediaExporterPdfHistoryResponse>>(
-    agentId: string,
-    params?: GetScreenrecordingPdfExportHistoryParams, options?: AxiosRequestConfig
+const listCallExports = <TData = AxiosResponse<WebitelMediaExporterListExportsResponse>>(
+    callId: string,
+    params?: ListCallExportsParams, options?: AxiosRequestConfig
  ): Promise<TData> => {
     return axios.get(
-      `/export/pdf/${agentId}/history`,{
+      `/calls/${callId}/exports/pdf`,{
     ...options,
         params: {...params, ...options?.params},}
     );
   }
 /**
- * @summary Download a previously generated PDF by export ID.
+ * @summary Creates a new task to generate a PDF export for a specific call.
+Useful for documenting call transcripts or associated media.
  */
-const downloadPdfExport = <TData = AxiosResponse<DownloadPdfExport200>>(
-    fileId: string,
-    params?: DownloadPdfExportParams, options?: AxiosRequestConfig
+const createCallExport = <TData = AxiosResponse<WebitelMediaExporterExportTask>>(
+    callId: string,
+    webitelMediaExporterPdfServiceCreateCallExportBody: WebitelMediaExporterPdfServiceCreateCallExportBody, options?: AxiosRequestConfig
  ): Promise<TData> => {
-    return axios.get(
-      `/export/pdf/${fileId}`,{
-    ...options,
-        params: {...params, ...options?.params},}
+    return axios.post(
+      `/calls/${callId}/exports/pdf`,
+      webitelMediaExporterPdfServiceCreateCallExportBody,options
+    );
+  }
+/**
+ * @summary Deletes a specific export record from the history.
+ */
+const deleteExport = <TData = AxiosResponse<WebitelMediaExporterDeleteExportResponse>>(
+    id: string, options?: AxiosRequestConfig
+ ): Promise<TData> => {
+    return axios.delete(
+      `/exports/pdf/history/${id}`,options
     );
   }
 
             // --- footer start
-            return {generateCallPdfExport,getCallPdfHistory,deletePdfExportRecord,generateScreenrecordingPdfExport,getScreenrecordingPdfExportHistory,downloadPdfExport}};
-export type GenerateCallPdfExportResult = AxiosResponse<WebitelMediaExporterPdfExportMetadata>
-export type GetCallPdfHistoryResult = AxiosResponse<WebitelMediaExporterPdfHistoryResponse>
-export type DeletePdfExportRecordResult = AxiosResponse<WebitelMediaExporterDeletePdfExportRecordResponse>
-export type GenerateScreenrecordingPdfExportResult = AxiosResponse<WebitelMediaExporterPdfExportMetadata>
-export type GetScreenrecordingPdfExportHistoryResult = AxiosResponse<WebitelMediaExporterPdfHistoryResponse>
-export type DownloadPdfExportResult = AxiosResponse<DownloadPdfExport200>
+            return {listScreenrecordingExports,createScreenrecordingExport,listCallExports,createCallExport,deleteExport}};
+export type ListScreenrecordingExportsResult = AxiosResponse<WebitelMediaExporterListExportsResponse>
+export type CreateScreenrecordingExportResult = AxiosResponse<WebitelMediaExporterExportTask>
+export type ListCallExportsResult = AxiosResponse<WebitelMediaExporterListExportsResponse>
+export type CreateCallExportResult = AxiosResponse<WebitelMediaExporterExportTask>
+export type DeleteExportResult = AxiosResponse<WebitelMediaExporterDeleteExportResponse>
 
             // --- footer end
           

package/src/gen/pdf-service/pdf-service.msw.api.gen.ts

@@ -18,104 +18,88 @@ import type {
 } from 'msw';
 
 import {
-  WebitelMediaExporterPdfExportStatus
+  WebitelMediaExporterExportStatus
 } from '.././_models';
 import type {
-  DownloadPdfExport200,
-  WebitelMediaExporterDeletePdfExportRecordResponse,
-  WebitelMediaExporterPdfExportMetadata,
-  WebitelMediaExporterPdfHistoryResponse
+  WebitelMediaExporterDeleteExportResponse,
+  WebitelMediaExporterExportTask,
+  WebitelMediaExporterListExportsResponse
 } from '.././_models';
 
 
-export const getGenerateCallPdfExportResponseMock = (overrideResponse: Partial< WebitelMediaExporterPdfExportMetadata > = {}): WebitelMediaExporterPdfExportMetadata => ({fileName: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), size: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), taskId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
+export const getListScreenrecordingExportsResponseMock = (overrideResponse: Partial< WebitelMediaExporterListExportsResponse > = {}): WebitelMediaExporterListExportsResponse => ({items: faker.helpers.arrayElement([Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({createdAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), createdBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), fileId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), name: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.helpers.arrayElement(Object.values(WebitelMediaExporterExportStatus)), undefined]), updatedAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), updatedBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])})), undefined]), next: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), page: faker.helpers.arrayElement([faker.number.int({min: undefined, max: undefined}), undefined]), ...overrideResponse})
 
-export const getGetCallPdfHistoryResponseMock = (overrideResponse: Partial< WebitelMediaExporterPdfHistoryResponse > = {}): WebitelMediaExporterPdfHistoryResponse => ({data: faker.helpers.arrayElement([Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({createdAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), createdBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), fileId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), name: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.helpers.arrayElement(Object.values(WebitelMediaExporterPdfExportStatus)), undefined]), updatedAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), updatedBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])})), undefined]), next: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), page: faker.helpers.arrayElement([faker.number.int({min: undefined, max: undefined}), undefined]), ...overrideResponse})
+export const getCreateScreenrecordingExportResponseMock = (overrideResponse: Partial< WebitelMediaExporterExportTask > = {}): WebitelMediaExporterExportTask => ({fileName: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), size: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.helpers.arrayElement(Object.values(WebitelMediaExporterExportStatus)), undefined]), taskId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
 
-export const getDeletePdfExportRecordResponseMock = (overrideResponse: Partial< WebitelMediaExporterDeletePdfExportRecordResponse > = {}): WebitelMediaExporterDeletePdfExportRecordResponse => ({id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
+export const getListCallExportsResponseMock = (overrideResponse: Partial< WebitelMediaExporterListExportsResponse > = {}): WebitelMediaExporterListExportsResponse => ({items: faker.helpers.arrayElement([Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({createdAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), createdBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), fileId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), name: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.helpers.arrayElement(Object.values(WebitelMediaExporterExportStatus)), undefined]), updatedAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), updatedBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])})), undefined]), next: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), page: faker.helpers.arrayElement([faker.number.int({min: undefined, max: undefined}), undefined]), ...overrideResponse})
 
-export const getGenerateScreenrecordingPdfExportResponseMock = (overrideResponse: Partial< WebitelMediaExporterPdfExportMetadata > = {}): WebitelMediaExporterPdfExportMetadata => ({fileName: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), size: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), taskId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
+export const getCreateCallExportResponseMock = (overrideResponse: Partial< WebitelMediaExporterExportTask > = {}): WebitelMediaExporterExportTask => ({fileName: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), size: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.helpers.arrayElement(Object.values(WebitelMediaExporterExportStatus)), undefined]), taskId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
 
-export const getGetScreenrecordingPdfExportHistoryResponseMock = (overrideResponse: Partial< WebitelMediaExporterPdfHistoryResponse > = {}): WebitelMediaExporterPdfHistoryResponse => ({data: faker.helpers.arrayElement([Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({createdAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), createdBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), fileId: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), mimeType: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), name: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), status: faker.helpers.arrayElement([faker.helpers.arrayElement(Object.values(WebitelMediaExporterPdfExportStatus)), undefined]), updatedAt: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), updatedBy: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])})), undefined]), next: faker.helpers.arrayElement([faker.datatype.boolean(), undefined]), page: faker.helpers.arrayElement([faker.number.int({min: undefined, max: undefined}), undefined]), ...overrideResponse})
+export const getDeleteExportResponseMock = (overrideResponse: Partial< WebitelMediaExporterDeleteExportResponse > = {}): WebitelMediaExporterDeleteExportResponse => ({id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
 
-export const getDownloadPdfExportResponseMock = (overrideResponse: Partial< DownloadPdfExport200 > = {}): DownloadPdfExport200 => ({error: faker.helpers.arrayElement([{code: faker.helpers.arrayElement([faker.number.int({min: undefined, max: undefined}), undefined]), details: faker.helpers.arrayElement([Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() => ({'@type': faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])})), undefined]), message: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])}, undefined]), result: faker.helpers.arrayElement([{data: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined])}, undefined]), ...overrideResponse})
 
-
-export const getGenerateCallPdfExportMockHandler = (overrideResponse?: WebitelMediaExporterPdfExportMetadata | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<WebitelMediaExporterPdfExportMetadata> | WebitelMediaExporterPdfExportMetadata), options?: RequestHandlerOptions) => {
-  return http.post('*/export/pdf/call/:callId', async (info) => {await delay(1000);
-  
-    return new HttpResponse(JSON.stringify(overrideResponse !== undefined
-    ? (typeof overrideResponse === "function" ? await overrideResponse(info) : overrideResponse)
-    : getGenerateCallPdfExportResponseMock()),
-      { status: 200,
-        headers: { 'Content-Type': 'application/json' }
-      })
-  }, options)
-}
-
-export const getGetCallPdfHistoryMockHandler = (overrideResponse?: WebitelMediaExporterPdfHistoryResponse | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<WebitelMediaExporterPdfHistoryResponse> | WebitelMediaExporterPdfHistoryResponse), options?: RequestHandlerOptions) => {
-  return http.get('*/export/pdf/call/:callId/history', async (info) => {await delay(1000);
+export const getListScreenrecordingExportsMockHandler = (overrideResponse?: WebitelMediaExporterListExportsResponse | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<WebitelMediaExporterListExportsResponse> | WebitelMediaExporterListExportsResponse), options?: RequestHandlerOptions) => {
+  return http.get('*/agents/:agentId/exports/pdf/screenrecordings', async (info) => {await delay(1000);
   
     return new HttpResponse(JSON.stringify(overrideResponse !== undefined
     ? (typeof overrideResponse === "function" ? await overrideResponse(info) : overrideResponse)
-    : getGetCallPdfHistoryResponseMock()),
+    : getListScreenrecordingExportsResponseMock()),
       { status: 200,
         headers: { 'Content-Type': 'application/json' }
       })
   }, options)
 }
 
-export const getDeletePdfExportRecordMockHandler = (overrideResponse?: WebitelMediaExporterDeletePdfExportRecordResponse | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<WebitelMediaExporterDeletePdfExportRecordResponse> | WebitelMediaExporterDeletePdfExportRecordResponse), options?: RequestHandlerOptions) => {
-  return http.delete('*/export/pdf/history/:id', async (info) => {await delay(1000);
+export const getCreateScreenrecordingExportMockHandler = (overrideResponse?: WebitelMediaExporterExportTask | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<WebitelMediaExporterExportTask> | WebitelMediaExporterExportTask), options?: RequestHandlerOptions) => {
+  return http.post('*/agents/:agentId/exports/pdf/screenrecordings', async (info) => {await delay(1000);
   
     return new HttpResponse(JSON.stringify(overrideResponse !== undefined
     ? (typeof overrideResponse === "function" ? await overrideResponse(info) : overrideResponse)
-    : getDeletePdfExportRecordResponseMock()),
+    : getCreateScreenrecordingExportResponseMock()),
       { status: 200,
         headers: { 'Content-Type': 'application/json' }
       })
   }, options)
 }
 
-export const getGenerateScreenrecordingPdfExportMockHandler = (overrideResponse?: WebitelMediaExporterPdfExportMetadata | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<WebitelMediaExporterPdfExportMetadata> | WebitelMediaExporterPdfExportMetadata), options?: RequestHandlerOptions) => {
-  return http.post('*/export/pdf/:agentId', async (info) => {await delay(1000);
+export const getListCallExportsMockHandler = (overrideResponse?: WebitelMediaExporterListExportsResponse | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<WebitelMediaExporterListExportsResponse> | WebitelMediaExporterListExportsResponse), options?: RequestHandlerOptions) => {
+  return http.get('*/calls/:callId/exports/pdf', async (info) => {await delay(1000);
   
     return new HttpResponse(JSON.stringify(overrideResponse !== undefined
     ? (typeof overrideResponse === "function" ? await overrideResponse(info) : overrideResponse)
-    : getGenerateScreenrecordingPdfExportResponseMock()),
+    : getListCallExportsResponseMock()),
       { status: 200,
         headers: { 'Content-Type': 'application/json' }
       })
   }, options)
 }
 
-export const getGetScreenrecordingPdfExportHistoryMockHandler = (overrideResponse?: WebitelMediaExporterPdfHistoryResponse | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<WebitelMediaExporterPdfHistoryResponse> | WebitelMediaExporterPdfHistoryResponse), options?: RequestHandlerOptions) => {
-  return http.get('*/export/pdf/:agentId/history', async (info) => {await delay(1000);
+export const getCreateCallExportMockHandler = (overrideResponse?: WebitelMediaExporterExportTask | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<WebitelMediaExporterExportTask> | WebitelMediaExporterExportTask), options?: RequestHandlerOptions) => {
+  return http.post('*/calls/:callId/exports/pdf', async (info) => {await delay(1000);
   
     return new HttpResponse(JSON.stringify(overrideResponse !== undefined
     ? (typeof overrideResponse === "function" ? await overrideResponse(info) : overrideResponse)
-    : getGetScreenrecordingPdfExportHistoryResponseMock()),
+    : getCreateCallExportResponseMock()),
       { status: 200,
         headers: { 'Content-Type': 'application/json' }
       })
   }, options)
 }
 
-export const getDownloadPdfExportMockHandler = (overrideResponse?: DownloadPdfExport200 | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Promise<DownloadPdfExport200> | DownloadPdfExport200), options?: RequestHandlerOptions) => {
-  return http.get('*/export/pdf/:fileId', async (info) => {await delay(1000);
+export const getDeleteExportMockHandler = (overrideResponse?: WebitelMediaExporterDeleteExportResponse | ((info: Parameters<Parameters<typeof http.delete>[1]>[0]) => Promise<WebitelMediaExporterDeleteExportResponse> | WebitelMediaExporterDeleteExportResponse), options?: RequestHandlerOptions) => {
+  return http.delete('*/exports/pdf/history/:id', async (info) => {await delay(1000);
   
     return new HttpResponse(JSON.stringify(overrideResponse !== undefined
     ? (typeof overrideResponse === "function" ? await overrideResponse(info) : overrideResponse)
-    : getDownloadPdfExportResponseMock()),
+    : getDeleteExportResponseMock()),
       { status: 200,
         headers: { 'Content-Type': 'application/json' }
       })
   }, options)
 }
 export const getPdfServiceMock = () => [
-  getGenerateCallPdfExportMockHandler(),
-  getGetCallPdfHistoryMockHandler(),
-  getDeletePdfExportRecordMockHandler(),
-  getGenerateScreenrecordingPdfExportMockHandler(),
-  getGetScreenrecordingPdfExportHistoryMockHandler(),
-  getDownloadPdfExportMockHandler()]
+  getListScreenrecordingExportsMockHandler(),
+  getCreateScreenrecordingExportMockHandler(),
+  getListCallExportsMockHandler(),
+  getCreateCallExportMockHandler(),
+  getDeleteExportMockHandler()]

package/src/gen/pdf-service/pdf-service.zod.gen.ts

@@ -8,140 +8,121 @@ import * as zod from 'zod/v4';
 
 
 /**
- * @summary Generate a new PDF export asynchronously by Call ID.
+ * @summary Lists the history of PDF exports for a specific agent.
  */
-export const generateCallPdfExportParams = zod.object({
-  "call_id": zod.string()
-})
-
-export const generateCallPdfExportBody = zod.object({
-  "fileIds": zod.array(zod.string()).optional().describe('Optional list of specific file IDs to include.'),
-  "from": zod.string().optional().describe('Start timestamp (Unix millis).'),
-  "to": zod.string().optional().describe('End timestamp (Unix millis).')
-})
-
-export const generateCallPdfExportResponse = zod.object({
-  "fileName": zod.string().optional().describe('File name of the export.'),
-  "mimeType": zod.string().optional().describe('MIME type, e.g., \"application/pdf\".'),
-  "size": zod.string().optional().describe('File size in bytes (0 if not ready).'),
-  "status": zod.string().optional().describe('Task status: pending | processing | done | failed.'),
-  "taskId": zod.string().optional().describe('Unique identifier of the task.')
-}).describe('Metadata about a PDF export task.')
-
-/**
- * @summary Get history of PDF exports for a specific Call.
- */
-export const getCallPdfHistoryParams = zod.object({
-  "call_id": zod.string()
+export const listScreenrecordingExportsParams = zod.object({
+  "agent_id": zod.string()
 })
 
-export const getCallPdfHistoryQueryParams = zod.object({
-  "page": zod.number().optional(),
-  "size": zod.number().optional()
+export const listScreenrecordingExportsQueryParams = zod.object({
+  "page": zod.number().optional().describe('Page number (1-based).'),
+  "size": zod.number().optional().describe('Number of items per page.')
 })
 
-export const getCallPdfHistoryResponseDataItemStatusDefault = "PDF_EXPORT_STATUS_UNSPECIFIED";
+export const listScreenrecordingExportsResponseItemsItemStatusDefault = "EXPORT_STATUS_UNSPECIFIED";
 
-export const getCallPdfHistoryResponse = zod.object({
-  "data": zod.array(zod.object({
+export const listScreenrecordingExportsResponse = zod.object({
+  "items": zod.array(zod.object({
   "createdAt": zod.string().optional().describe('Creation timestamp (Unix millis).'),
-  "createdBy": zod.string().optional().describe('User ID who created the export.'),
-  "fileId": zod.string().optional().describe('Related file ID.'),
-  "id": zod.string().optional().describe('Export ID.'),
-  "mimeType": zod.string().optional().describe('MIME type of the export.'),
-  "name": zod.string().optional().describe('Export name.'),
-  "status": zod.enum(['PDF_EXPORT_STATUS_UNSPECIFIED', 'PDF_EXPORT_STATUS_PENDING', 'PDF_EXPORT_STATUS_PROCESSING', 'PDF_EXPORT_STATUS_DONE', 'PDF_EXPORT_STATUS_FAILED']).default(getCallPdfHistoryResponseDataItemStatusDefault).describe('Status of the PDF export process.\n\n - PDF_EXPORT_STATUS_UNSPECIFIED: Default value.\n - PDF_EXPORT_STATUS_PENDING: Task is waiting to start.\n - PDF_EXPORT_STATUS_PROCESSING: Task is in progress.\n - PDF_EXPORT_STATUS_DONE: Task is completed successfully.\n - PDF_EXPORT_STATUS_FAILED: Task failed.'),
-  "updatedAt": zod.string().optional().describe('Update timestamp (Unix millis).'),
-  "updatedBy": zod.string().optional().describe('User ID who last updated the export.')
-}).describe('Represents a single PDF export record.')).optional().describe('List of export history records.'),
-  "next": zod.boolean().optional().describe('True if there is a next page.'),
+  "createdBy": zod.string().optional().describe('User ID who initiated the export.'),
+  "fileId": zod.string().optional().describe('Reference to the file in the storage system.'),
+  "id": zod.string().optional().describe('Internal database record ID.'),
+  "mimeType": zod.string().optional().describe('MIME type of the generated file.'),
+  "name": zod.string().optional().describe('Display name of the export.'),
+  "status": zod.enum(['EXPORT_STATUS_UNSPECIFIED', 'PENDING', 'PROCESSING', 'DONE', 'FAILED']).default(listScreenrecordingExportsResponseItemsItemStatusDefault).describe('Status of the PDF generation process.\n\n - PENDING: Task is queued and waiting for a worker.\n - PROCESSING: PDF is currently being rendered.\n - DONE: Export finished successfully.\n - FAILED: Export failed during generation.'),
+  "updatedAt": zod.string().optional().describe('Last update timestamp (Unix millis).'),
+  "updatedBy": zod.string().optional().describe('User ID who last modified the record.')
+}).describe('Represents a persisted record of a PDF export.')).optional().describe('List of export records.'),
+  "next": zod.boolean().optional().describe('Indicates if there are more records available.'),
   "page": zod.number().optional().describe('Current page number.')
-}).describe('Response containing a page of export history.')
-
-export const deletePdfExportRecordParams = zod.object({
-  "id": zod.string()
-})
-
-export const deletePdfExportRecordResponse = zod.object({
-  "id": zod.string().optional()
-})
+}).describe('Response containing a page of export history records.')
 
 /**
- * @summary Generate a new PDF export asynchronously.
-Returns metadata about the created export task.
+ * @summary Creates a new task to generate a PDF export for an agent's screen recordings.
+This operation is asynchronous and returns a task metadata.
  */
-export const generateScreenrecordingPdfExportParams = zod.object({
-  "agent_id": zod.string().describe('Agent ID for which the export is generated.')
+export const createScreenrecordingExportParams = zod.object({
+  "agent_id": zod.string().describe('Unique identifier of the agent.')
 })
 
-export const generateScreenrecordingPdfExportBodyChannelDefault = "CALL";
+export const createScreenrecordingExportBody = zod.object({
+  "fileIds": zod.array(zod.string()).optional().describe('Optional: specific file IDs to include in the PDF.'),
+  "from": zod.string().optional().describe('Start timestamp of the range (Unix millis).'),
+  "to": zod.string().optional().describe('End timestamp of the range (Unix millis).')
+}).describe('Request for generating a screen recording PDF.')
 
-export const generateScreenrecordingPdfExportBody = zod.object({
-  "channel": zod.enum(['CALL', 'SCREENRECORDING']).default(generateScreenrecordingPdfExportBodyChannelDefault),
-  "fileIds": zod.array(zod.string()).optional().describe('Optional list of specific file IDs to include.'),
-  "from": zod.string().optional().describe('Start timestamp (Unix millis).'),
-  "to": zod.string().optional().describe('End timestamp (Unix millis).')
-}).describe('Request for generating a PDF export.')
+export const createScreenrecordingExportResponseStatusDefault = "EXPORT_STATUS_UNSPECIFIED";
 
-export const generateScreenrecordingPdfExportResponse = zod.object({
-  "fileName": zod.string().optional().describe('File name of the export.'),
-  "mimeType": zod.string().optional().describe('MIME type, e.g., \"application/pdf\".'),
-  "size": zod.string().optional().describe('File size in bytes (0 if not ready).'),
-  "status": zod.string().optional().describe('Task status: pending | processing | done | failed.'),
-  "taskId": zod.string().optional().describe('Unique identifier of the task.')
-}).describe('Metadata about a PDF export task.')
+export const createScreenrecordingExportResponse = zod.object({
+  "fileName": zod.string().optional().describe('Target name of the PDF file.'),
+  "mimeType": zod.string().optional().describe('MIME type (usually application/pdf).'),
+  "size": zod.string().optional().describe('File size in bytes (0 if not yet generated).'),
+  "status": zod.enum(['EXPORT_STATUS_UNSPECIFIED', 'PENDING', 'PROCESSING', 'DONE', 'FAILED']).default(createScreenrecordingExportResponseStatusDefault).describe('Status of the PDF generation process.\n\n - PENDING: Task is queued and waiting for a worker.\n - PROCESSING: PDF is currently being rendered.\n - DONE: Export finished successfully.\n - FAILED: Export failed during generation.'),
+  "taskId": zod.string().optional().describe('Unique ID to track the background task.')
+}).describe('Metadata about an export task immediately after creation.')
 
 /**
- * @summary Get paginated history of PDF exports for a given agent.
+ * @summary Lists the history of PDF exports for a specific call ID.
  */
-export const getScreenrecordingPdfExportHistoryParams = zod.object({
-  "agent_id": zod.string().describe('Agent ID.')
+export const listCallExportsParams = zod.object({
+  "call_id": zod.string()
 })
 
-export const getScreenrecordingPdfExportHistoryQueryParams = zod.object({
-  "page": zod.number().optional().describe('Page number (starting from 1).'),
-  "size": zod.number().optional().describe('Page size (number of records per page).')
+export const listCallExportsQueryParams = zod.object({
+  "page": zod.number().optional().describe('Page number (1-based).'),
+  "size": zod.number().optional().describe('Number of items per page.')
 })
 
-export const getScreenrecordingPdfExportHistoryResponseDataItemStatusDefault = "PDF_EXPORT_STATUS_UNSPECIFIED";
+export const listCallExportsResponseItemsItemStatusDefault = "EXPORT_STATUS_UNSPECIFIED";
 
-export const getScreenrecordingPdfExportHistoryResponse = zod.object({
-  "data": zod.array(zod.object({
+export const listCallExportsResponse = zod.object({
+  "items": zod.array(zod.object({
   "createdAt": zod.string().optional().describe('Creation timestamp (Unix millis).'),
-  "createdBy": zod.string().optional().describe('User ID who created the export.'),
-  "fileId": zod.string().optional().describe('Related file ID.'),
-  "id": zod.string().optional().describe('Export ID.'),
-  "mimeType": zod.string().optional().describe('MIME type of the export.'),
-  "name": zod.string().optional().describe('Export name.'),
-  "status": zod.enum(['PDF_EXPORT_STATUS_UNSPECIFIED', 'PDF_EXPORT_STATUS_PENDING', 'PDF_EXPORT_STATUS_PROCESSING', 'PDF_EXPORT_STATUS_DONE', 'PDF_EXPORT_STATUS_FAILED']).default(getScreenrecordingPdfExportHistoryResponseDataItemStatusDefault).describe('Status of the PDF export process.\n\n - PDF_EXPORT_STATUS_UNSPECIFIED: Default value.\n - PDF_EXPORT_STATUS_PENDING: Task is waiting to start.\n - PDF_EXPORT_STATUS_PROCESSING: Task is in progress.\n - PDF_EXPORT_STATUS_DONE: Task is completed successfully.\n - PDF_EXPORT_STATUS_FAILED: Task failed.'),
-  "updatedAt": zod.string().optional().describe('Update timestamp (Unix millis).'),
-  "updatedBy": zod.string().optional().describe('User ID who last updated the export.')
-}).describe('Represents a single PDF export record.')).optional().describe('List of export history records.'),
-  "next": zod.boolean().optional().describe('True if there is a next page.'),
+  "createdBy": zod.string().optional().describe('User ID who initiated the export.'),
+  "fileId": zod.string().optional().describe('Reference to the file in the storage system.'),
+  "id": zod.string().optional().describe('Internal database record ID.'),
+  "mimeType": zod.string().optional().describe('MIME type of the generated file.'),
+  "name": zod.string().optional().describe('Display name of the export.'),
+  "status": zod.enum(['EXPORT_STATUS_UNSPECIFIED', 'PENDING', 'PROCESSING', 'DONE', 'FAILED']).default(listCallExportsResponseItemsItemStatusDefault).describe('Status of the PDF generation process.\n\n - PENDING: Task is queued and waiting for a worker.\n - PROCESSING: PDF is currently being rendered.\n - DONE: Export finished successfully.\n - FAILED: Export failed during generation.'),
+  "updatedAt": zod.string().optional().describe('Last update timestamp (Unix millis).'),
+  "updatedBy": zod.string().optional().describe('User ID who last modified the record.')
+}).describe('Represents a persisted record of a PDF export.')).optional().describe('List of export records.'),
+  "next": zod.boolean().optional().describe('Indicates if there are more records available.'),
   "page": zod.number().optional().describe('Current page number.')
-}).describe('Response containing a page of export history.')
+}).describe('Response containing a page of export history records.')
 
 /**
- * @summary Download a previously generated PDF by export ID.
+ * @summary Creates a new task to generate a PDF export for a specific call.
+Useful for documenting call transcripts or associated media.
  */
-export const downloadPdfExportParams = zod.object({
-  "file_id": zod.string().describe('Unique export identifier.')
+export const createCallExportParams = zod.object({
+  "call_id": zod.string().describe('Unique identifier of the call.')
 })
 
-export const downloadPdfExportQueryParams = zod.object({
-  "domainId": zod.string().optional().describe('Domain ID for authorization.')
-})
+export const createCallExportBody = zod.object({
+  "fileIds": zod.array(zod.string()).optional().describe('Optional: specific file IDs to include in the PDF.'),
+  "from": zod.string().optional().describe('Start timestamp of the range (Unix millis).'),
+  "to": zod.string().optional().describe('End timestamp of the range (Unix millis).')
+}).describe('Request for generating a call media PDF.')
 
-export const downloadPdfExportResponse = zod.object({
-  "error": zod.object({
-  "code": zod.number().optional(),
-  "details": zod.array(zod.object({
-  "@type": zod.string().optional()
-})).optional(),
-  "message": zod.string().optional()
-}).optional(),
-  "result": zod.object({
-  "data": zod.string().optional().describe('Raw PDF file bytes (chunked).')
-}).optional().describe('Chunked response with PDF binary data.')
+export const createCallExportResponseStatusDefault = "EXPORT_STATUS_UNSPECIFIED";
+
+export const createCallExportResponse = zod.object({
+  "fileName": zod.string().optional().describe('Target name of the PDF file.'),
+  "mimeType": zod.string().optional().describe('MIME type (usually application/pdf).'),
+  "size": zod.string().optional().describe('File size in bytes (0 if not yet generated).'),
+  "status": zod.enum(['EXPORT_STATUS_UNSPECIFIED', 'PENDING', 'PROCESSING', 'DONE', 'FAILED']).default(createCallExportResponseStatusDefault).describe('Status of the PDF generation process.\n\n - PENDING: Task is queued and waiting for a worker.\n - PROCESSING: PDF is currently being rendered.\n - DONE: Export finished successfully.\n - FAILED: Export failed during generation.'),
+  "taskId": zod.string().optional().describe('Unique ID to track the background task.')
+}).describe('Metadata about an export task immediately after creation.')
+
+/**
+ * @summary Deletes a specific export record from the history.
+ */
+export const deleteExportParams = zod.object({
+  "id": zod.string().describe('ID of the record to remove.')
 })
 
+export const deleteExportResponse = zod.object({
+  "id": zod.string().optional().describe('ID of the deleted record.')
+}).describe('Response confirming the deletion of a record.')
+

package/types/gen/_models/{getScreenrecordingPdfExportHistoryParams.d.ts → listCallExportsParams.d.ts}

@@ -4,13 +4,13 @@
  * Webitel API
  * OpenAPI spec version: 24.04.0
  */
-export type GetScreenrecordingPdfExportHistoryParams = {
+export type ListCallExportsParams = {
     /**
-     * Page number (starting from 1).
+     * Page number (1-based).
      */
     page?: number;
     /**
-     * Page size (number of records per page).
+     * Number of items per page.
      */
     size?: number;
 };

package/types/gen/_models/{getCallPdfHistoryParams.d.ts → listScreenrecordingExportsParams.d.ts}

@@ -4,7 +4,13 @@
  * Webitel API
  * OpenAPI spec version: 24.04.0
  */
-export type GetCallPdfHistoryParams = {
+export type ListScreenrecordingExportsParams = {
+    /**
+     * Page number (1-based).
+     */
     page?: number;
+    /**
+     * Number of items per page.
+     */
     size?: number;
 };

package/types/gen/_models/webitelMediaExporterDeleteExportResponse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generated by orval v7.17.0 🍺
+ * Do not edit manually.
+ * Webitel API
+ * OpenAPI spec version: 24.04.0
+ */
+/**
+ * Response confirming the deletion of a record.
+ */
+export interface WebitelMediaExporterDeleteExportResponse {
+    /** ID of the deleted record. */
+    id?: string;
+}

package/types/gen/_models/webitelMediaExporterExportRecord.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generated by orval v7.17.0 🍺
+ * Do not edit manually.
+ * Webitel API
+ * OpenAPI spec version: 24.04.0
+ */
+import type { WebitelMediaExporterExportStatus } from './webitelMediaExporterExportStatus';
+/**
+ * Represents a persisted record of a PDF export.
+ */
+export interface WebitelMediaExporterExportRecord {
+    /** Creation timestamp (Unix millis). */
+    createdAt?: string;
+    /** User ID who initiated the export. */
+    createdBy?: string;
+    /** Reference to the file in the storage system. */
+    fileId?: string;
+    /** Internal database record ID. */
+    id?: string;
+    /** MIME type of the generated file. */
+    mimeType?: string;
+    /** Display name of the export. */
+    name?: string;
+    /** Final status of the export process. */
+    status?: WebitelMediaExporterExportStatus;
+    /** Last update timestamp (Unix millis). */
+    updatedAt?: string;
+    /** User ID who last modified the record. */
+    updatedBy?: string;
+}