@webitel/api-services 0.0.91 → 0.0.93

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

@@ -12,13 +12,13 @@ import type {
 } from 'axios';
 
 import type {
-  DownloadPdfExport200,
-  DownloadPdfExportParams,
-  GetPdfExportHistoryParams,
-  WebitelMediaExporterDeletePdfExportRecordResponse,
-  WebitelMediaExporterPdfExportMetadata,
-  WebitelMediaExporterPdfHistoryResponse,
-  WebitelMediaExporterPdfServiceGeneratePdfExportBody
+  ListCallExportsParams,
+  ListScreenrecordingExportsParams,
+  WebitelMediaExporterDeleteExportResponse,
+  WebitelMediaExporterExportTask,
+  WebitelMediaExporterListExportsResponse,
+  WebitelMediaExporterPdfServiceCreateCallExportBody,
+  WebitelMediaExporterPdfServiceCreateScreenrecordingExportBody
 } from '.././_models';
 
 
@@ -33,59 +33,76 @@ import type {
            = () => {
 
             // --- header end
-          const deletePdfExportRecord = <TData = AxiosResponse<WebitelMediaExporterDeletePdfExportRecordResponse>>(
-    id: string, options?: AxiosRequestConfig
+          /**
+ * @summary Lists the history of PDF exports for a specific agent.
+ */
+const listScreenrecordingExports = <TData = AxiosResponse<WebitelMediaExporterListExportsResponse>>(
+    agentId: string,
+    params?: ListScreenrecordingExportsParams, options?: AxiosRequestConfig
  ): Promise<TData> => {
-    return axios.delete(
-      `/export/pdf/history/${id}`,options
+    return axios.get(
+      `/agents/${agentId}/exports/pdf/screenrecordings`,{
+    ...options,
+        params: {...params, ...options?.params},}
     );
   }
 /**
- * @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 generatePdfExport = <TData = AxiosResponse<WebitelMediaExporterPdfExportMetadata>>(
+const createScreenrecordingExport = <TData = AxiosResponse<WebitelMediaExporterExportTask>>(
     agentId: string,
-    webitelMediaExporterPdfServiceGeneratePdfExportBody: WebitelMediaExporterPdfServiceGeneratePdfExportBody, options?: AxiosRequestConfig
+    webitelMediaExporterPdfServiceCreateScreenrecordingExportBody: WebitelMediaExporterPdfServiceCreateScreenrecordingExportBody, options?: AxiosRequestConfig
  ): Promise<TData> => {
     return axios.post(
-      `/export/pdf/${agentId}`,
-      webitelMediaExporterPdfServiceGeneratePdfExportBody,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 getPdfExportHistory = <TData = AxiosResponse<WebitelMediaExporterPdfHistoryResponse>>(
-    agentId: string,
-    params?: GetPdfExportHistoryParams, 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 {deletePdfExportRecord,generatePdfExport,getPdfExportHistory,downloadPdfExport}};
-export type DeletePdfExportRecordResult = AxiosResponse<WebitelMediaExporterDeletePdfExportRecordResponse>
-export type GeneratePdfExportResult = AxiosResponse<WebitelMediaExporterPdfExportMetadata>
-export type GetPdfExportHistoryResult = 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,74 +18,88 @@ import type {
 } from 'msw';
 
 import {
-  WebitelMediaExporterPdfExportStatus
+  WebitelMediaExporterExportStatus
 } from '.././_models';
 import type {
-  DownloadPdfExport200,
-  WebitelMediaExporterDeletePdfExportRecordResponse,
-  WebitelMediaExporterPdfExportMetadata,
-  WebitelMediaExporterPdfHistoryResponse
+  WebitelMediaExporterDeleteExportResponse,
+  WebitelMediaExporterExportTask,
+  WebitelMediaExporterListExportsResponse
 } from '.././_models';
 
 
-export const getDeletePdfExportRecordResponseMock = (overrideResponse: Partial< WebitelMediaExporterDeletePdfExportRecordResponse > = {}): WebitelMediaExporterDeletePdfExportRecordResponse => ({id: 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 getGeneratePdfExportResponseMock = (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 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 getGetPdfExportHistoryResponseMock = (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 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 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 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 getDeleteExportResponseMock = (overrideResponse: Partial< WebitelMediaExporterDeleteExportResponse > = {}): WebitelMediaExporterDeleteExportResponse => ({id: faker.helpers.arrayElement([faker.string.alpha({length: {min: 10, max: 20}}), undefined]), ...overrideResponse})
 
-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 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)
+    : getListScreenrecordingExportsResponseMock()),
+      { status: 200,
+        headers: { 'Content-Type': 'application/json' }
+      })
+  }, options)
+}
+
+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 getGeneratePdfExportMockHandler = (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)
-    : getGeneratePdfExportResponseMock()),
+    : getListCallExportsResponseMock()),
       { status: 200,
         headers: { 'Content-Type': 'application/json' }
       })
   }, options)
 }
 
-export const getGetPdfExportHistoryMockHandler = (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)
-    : getGetPdfExportHistoryResponseMock()),
+    : 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 = () => [
-  getDeletePdfExportRecordMockHandler(),
-  getGeneratePdfExportMockHandler(),
-  getGetPdfExportHistoryMockHandler(),
-  getDownloadPdfExportMockHandler()]
+  getListScreenrecordingExportsMockHandler(),
+  getCreateScreenrecordingExportMockHandler(),
+  getListCallExportsMockHandler(),
+  getCreateCallExportMockHandler(),
+  getDeleteExportMockHandler()]

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

@@ -7,90 +7,122 @@
 import * as zod from 'zod/v4';
 
 
-export const deletePdfExportRecordParams = zod.object({
-  "id": zod.string()
+/**
+ * @summary Lists the history of PDF exports for a specific agent.
+ */
+export const listScreenrecordingExportsParams = zod.object({
+  "agent_id": zod.string()
 })
 
-export const deletePdfExportRecordResponse = zod.object({
-  "id": zod.string().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 listScreenrecordingExportsResponseItemsItemStatusDefault = "EXPORT_STATUS_UNSPECIFIED";
+
+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 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 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 generatePdfExportParams = 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 generatePdfExportBodyChannelDefault = "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 generatePdfExportBody = zod.object({
-  "channel": zod.enum(['CALL', 'SCREENRECORDING']).default(generatePdfExportBodyChannelDefault),
-  "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 generatePdfExportResponse = 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 getPdfExportHistoryParams = zod.object({
-  "agent_id": zod.string().describe('Agent ID.')
+export const listCallExportsParams = zod.object({
+  "call_id": zod.string()
 })
 
-export const getPdfExportHistoryQueryParams = 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 getPdfExportHistoryResponseDataItemStatusDefault = "PDF_EXPORT_STATUS_UNSPECIFIED";
+export const listCallExportsResponseItemsItemStatusDefault = "EXPORT_STATUS_UNSPECIFIED";
 
-export const getPdfExportHistoryResponse = 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(getPdfExportHistoryResponseDataItemStatusDefault).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 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.')
 
-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.')
+/**
+ * @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.')
+