@ikatec/digisac-api-sdk 4.9.0 → 4.11.0

package/src/apis/customFields/CustomFieldsApi.ts

@@ -1,13 +1,24 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
 import type { CustomField, CreateCustomFieldPayload, UpdateCustomFieldPayload } from './types'
 
 export class CustomFieldsApi extends BaseCrudApi<
   CustomField,
   CreateCustomFieldPayload,
-  UpdateCustomFieldPayload
+  UpdateCustomFieldPayload,
+  ListQuery<CustomField>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/custom-fields')
   }
+
+  /**
+   * Deletes a custom field. Resolves the text `'OK'`.
+   * @permissions customFields.view OR customFields.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/departments/DepartmentsApi.test.ts

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { DepartmentsApi } from './DepartmentsApi'
+import type { ApiClient } from '../../core/ApiClient'
+import type { Department } from './types'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+const department: Department = {
+  id: 'dep-1',
+  name: 'Support',
+  accountId: 'acc-1',
+  distributionId: null,
+  archivedAt: '2026-01-01T00:00:00Z',
+  createdAt: '2026-01-01T00:00:00Z',
+  updatedAt: '2026-01-01T00:00:00Z',
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('DepartmentsApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: DepartmentsApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new DepartmentsApi(client)
+  })
+
+  describe('archiveWithValidation', () => {
+    it('calls client.post with /departments/:id/archive and { archive: true }', async () => {
+      vi.mocked(client.post).mockResolvedValue(department)
+      const result = await api.archiveWithValidation('dep-1', { archive: true })
+      expect(client.post).toHaveBeenCalledWith(
+        '/departments/dep-1/archive',
+        { archive: true },
+        undefined,
+      )
+      expect(result).toEqual(department)
+    })
+
+    it('restores with { archive: false } and forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.archiveWithValidation('dep-1', { archive: false }, headers)
+      expect(client.post).toHaveBeenCalledWith(
+        '/departments/dep-1/archive',
+        { archive: false },
+        headers,
+      )
+    })
+  })
+
+  describe('archive / unarchive (PUT { archivedAt })', () => {
+    it('archive sends the current time in archivedAt', async () => {
+      await api.archive('dep-1')
+      expect(client.put).toHaveBeenCalledWith(
+        '/departments/dep-1',
+        { archivedAt: expect.any(String) },
+        undefined,
+      )
+    })
+
+    it('unarchive sends archivedAt null', async () => {
+      await api.unarchive('dep-1')
+      expect(client.put).toHaveBeenCalledWith('/departments/dep-1', { archivedAt: null }, undefined)
+    })
+  })
+
+  describe('deleteById', () => {
+    it("calls client.delete with /departments/:id and resolves 'OK'", async () => {
+      vi.mocked(client.delete).mockResolvedValue('OK')
+      const result = await api.deleteById('dep-1')
+      expect(client.delete).toHaveBeenCalledWith('/departments/dep-1', undefined)
+      expect(result).toBe('OK')
+    })
+  })
+})

package/src/apis/departments/DepartmentsApi.ts

@@ -1,13 +1,52 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { ArchivableCrudApi } from '../../core/ArchivableCrudApi'
-import type { Department, CreateDepartmentPayload, UpdateDepartmentPayload } from './types'
+import type {
+  Department,
+  CreateDepartmentPayload,
+  UpdateDepartmentPayload,
+  ArchiveDepartmentPayload,
+} from './types'
 
 export class DepartmentsApi extends ArchivableCrudApi<
   Department,
   CreateDepartmentPayload,
-  UpdateDepartmentPayload
+  UpdateDepartmentPayload,
+  ListQuery<Department>,
+  'OK'
 > {
   constructor(client: ApiClient) {
     super(client, '/departments')
   }
+
+  /**
+   * Archives (`archive: true`) or restores (`archive: false`) a department through the route used
+   * by the UI, which enforces what {@link archive}/{@link unarchive} (a plain `PUT { archivedAt }`)
+   * skip: archiving refuses (403 `Cannot archive department.`, with the reasons and the open
+   * tickets count) a department in use, and clears it as the default department of contacts and
+   * connections, marks its schedules as done and unlinks its users and quick replies. Resolves the
+   * stored department (not transformed); an unknown id answers 500.
+   * @permissions departments.view OR departments.archive
+   */
+  archiveWithValidation(
+    id: string,
+    body: ArchiveDepartmentPayload,
+    headers?: Record<string, string>,
+  ): Promise<Department> {
+    return this.client.post<Department, ArchiveDepartmentPayload>(
+      `${this.basePath}/${id}/archive`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a department. Resolves the text `'OK'`; a department that is the default of the account
+   * or that is referenced in the attendant name visibility settings is refused, and an unknown id
+   * answers 500.
+   * @permissions departments.view OR departments.archive
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<'OK'> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/departments/types.ts

@@ -26,3 +26,9 @@ export type UpdateDepartmentPayload = {
   distributionId?: string | null
   archivedAt?: string | null
 }
+
+/** Body of `DepartmentsApi.archiveWithValidation`. */
+export type ArchiveDepartmentPayload = {
+  /** `true` archives, `false` restores. */
+  archive: boolean
+}

package/src/apis/distribution/DistributionApi.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { DistributionApi } from './DistributionApi'
+import type { ApiClient } from '../../core/ApiClient'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('DistributionApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: DistributionApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new DistributionApi(client)
+  })
+
+  describe('create', () => {
+    it('posts the body, links included, to /distribution', async () => {
+      vi.mocked(client.post).mockResolvedValue(undefined)
+      const body = { name: 'QA', maxNum: 1, redistributeAll: false, departments: [{ id: 'dep-1' }] }
+      const result = await api.create(body)
+      expect(client.post).toHaveBeenCalledWith('/distribution', body, undefined)
+      expect(result).toBeUndefined()
+    })
+  })
+
+  describe('updateById', () => {
+    it('sends the id in the body too, which is where the backend reads it', async () => {
+      vi.mocked(client.put).mockResolvedValue([])
+      await api.updateById('dist-1', { name: 'QA', roles: [{ id: 'role-1' }] })
+      expect(client.put).toHaveBeenCalledWith(
+        '/distribution/dist-1',
+        { name: 'QA', roles: [{ id: 'role-1' }], id: 'dist-1' },
+        undefined,
+      )
+    })
+
+    it('keeps the id of the URL over an id of the body and forwards custom headers', async () => {
+      const headers = { 'X-Custom': 'value' }
+      await api.updateById('dist-1', { id: 'other' } as never, headers)
+      expect(client.put).toHaveBeenCalledWith('/distribution/dist-1', { id: 'dist-1' }, headers)
+    })
+  })
+
+  describe('deleteById', () => {
+    it('calls client.delete with /distribution/:id', async () => {
+      vi.mocked(client.delete).mockResolvedValue(undefined)
+      await api.deleteById('dist-1')
+      expect(client.delete).toHaveBeenCalledWith('/distribution/dist-1', undefined)
+    })
+  })
+})

package/src/apis/distribution/DistributionApi.ts

@@ -1,13 +1,62 @@
 import type { ApiClient } from '../../core/ApiClient'
+import type { ListQuery } from '../../core/types'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
+import type { Department } from '../departments/types'
 import type { Distribution, CreateDistributionPayload, UpdateDistributionPayload } from './types'
 
+/**
+ * Ticket distribution rules. `getById` answers `null` for an unknown id and always includes `departments` and
+ * `roles` (the query is ignored).
+ */
 export class DistributionApi extends BaseCrudApi<
   Distribution,
   CreateDistributionPayload,
-  UpdateDistributionPayload
+  UpdateDistributionPayload,
+  ListQuery<Distribution>,
+  void,
+  Distribution | undefined,
+  Distribution | Department[]
 > {
   constructor(client: ApiClient) {
     super(client, '/distribution')
   }
+
+  /**
+   * Creates a distribution. Resolves the distribution (without `departments`/`roles`), or no body
+   * (`undefined`) when `departments` is sent — find it by name with `getMany` in that case.
+   * @permissions distribution.create
+   */
+  override create(
+    body: CreateDistributionPayload,
+    headers?: Record<string, string>,
+  ): Promise<Distribution | undefined> {
+    return super.create(body, headers)
+  }
+
+  /**
+   * Updates a distribution. The backend reads the id from the body, so it is sent there too. It replaces
+   * the links: omitting `roles` or `departments` clears them. Resolves the stored distribution (with
+   * `deletedAt`, without the links) or, when `departments` is sent, the updated departments. An unknown id
+   * answers 500.
+   * @permissions distribution.view OR distribution.update
+   */
+  override updateById(
+    id: string,
+    body: UpdateDistributionPayload,
+    headers?: Record<string, string>,
+  ): Promise<Distribution | Department[]> {
+    return this.client.put<Distribution | Department[], UpdateDistributionPayload & { id: string }>(
+      `${this.basePath}/${id}`,
+      { ...body, id },
+      headers,
+    )
+  }
+
+  /**
+   * Deletes a distribution. Resolves with no body, also for an unknown id (200).
+   * @permissions distribution.view OR distribution.destroy
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<void> {
+    return super.deleteById(id, headers)
+  }
 }

package/src/apis/distribution/types.ts

@@ -11,7 +11,8 @@ export type Distribution = {
   distributeQueue: boolean
   accountId: string
   archivedAt: string | null
-  deletedAt: string | null
+  /** Only in the answer of `updateById` (the stored model, not transformed). */
+  deletedAt?: string | null
   createdAt: string
   updatedAt: string
   // relationships
@@ -21,6 +22,9 @@ export type Distribution = {
 
 export type DistributionRelationships = 'departments' | 'roles'
 
+/** A department or a role linked to a distribution (only the id is read). */
+export type DistributionLink = { id: string }
+
 export type CreateDistributionPayload = {
   name: string
   maxNum: number
@@ -28,8 +32,17 @@ export type CreateDistributionPayload = {
   timeToRedistribute?: number
   redistributeAssignedTickets?: boolean
   distributeQueue?: boolean
+  /** An archived distribution is skipped by the distribution crons. */
+  archivedAt?: string | null
+  /** Departments to distribute; a department has at most one distribution. */
+  departments?: DistributionLink[]
+  roles?: DistributionLink[]
 }
 
+/**
+ * The update replaces the links: send `departments` and `roles` again to keep them — omitting them
+ * clears them.
+ */
 export type UpdateDistributionPayload = {
   name?: string
   maxNum?: number
@@ -37,4 +50,7 @@ export type UpdateDistributionPayload = {
   timeToRedistribute?: number
   redistributeAssignedTickets?: boolean
   distributeQueue?: boolean
+  archivedAt?: string | null
+  departments?: DistributionLink[]
+  roles?: DistributionLink[]
 }

package/src/apis/files/FilesApi.test.ts

@@ -0,0 +1,122 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { FilesApi } from './FilesApi'
+import type { ApiClient } from '../../core/ApiClient'
+import { ApiConnectionError, ApiError } from '../../core/errors'
+import type { CreateToUploadResult } from './types'
+
+// ── Mock client factory ──────────────────────────────────────────────
+
+function createMockClient(): ApiClient {
+  return {
+    setAccessToken: vi.fn().mockReturnThis(),
+    request: vi.fn(),
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+  }
+}
+
+const URL_TO_UPLOAD = 'https://storage.example.com/acc-1/file-1.plain?X-Amz-Signature=abc'
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe('FilesApi', () => {
+  let client: ReturnType<typeof createMockClient>
+  let api: FilesApi
+
+  beforeEach(() => {
+    client = createMockClient()
+    api = new FilesApi(client)
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('createToUpload', () => {
+    it('calls client.post with /files/create-to-upload and body', async () => {
+      const created: CreateToUploadResult = {
+        urlToUpload: URL_TO_UPLOAD,
+        id: 'file-1',
+        name: 'report.txt',
+        mimetype: 'text/plain',
+      }
+      vi.mocked(client.post).mockResolvedValue(created)
+      const body = { name: 'report.txt', mimetype: 'text/plain', attachedType: 'campaign.file' }
+      const result = await api.createToUpload(body)
+      expect(client.post).toHaveBeenCalledWith('/files/create-to-upload', body, undefined)
+      expect(result).toEqual(created)
+    })
+  })
+
+  describe('upload', () => {
+    it('sends through client.requestExternal when the client has it', async () => {
+      const requestExternal = vi.fn().mockResolvedValue(new Response(null, { status: 200 }))
+      const fetchSpy = vi.spyOn(globalThis, 'fetch')
+      api = new FilesApi({ ...client, requestExternal })
+      await api.upload(URL_TO_UPLOAD, 'content', 'text/plain')
+      expect(requestExternal).toHaveBeenCalledWith('PUT', URL_TO_UPLOAD, 'content', {
+        'Content-Type': 'text/plain',
+      })
+      expect(fetchSpy).not.toHaveBeenCalled()
+    })
+
+    it('without client.requestExternal, PUTs the content to the signed URL with the global fetch', async () => {
+      const spy = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue(new Response(null, { status: 200 }))
+      await api.upload(URL_TO_UPLOAD, 'content', 'text/plain')
+      expect(spy).toHaveBeenCalledWith(URL_TO_UPLOAD, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/plain' },
+        body: 'content',
+      })
+      expect(client.request).not.toHaveBeenCalled()
+    })
+
+    it('throws ApiError when the storage refuses the upload', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+        new Response('<Error><Code>SignatureDoesNotMatch</Code></Error>', {
+          status: 403,
+          statusText: 'Forbidden',
+        }),
+      )
+      const captured = await api.upload(URL_TO_UPLOAD, 'content', 'text/plain').catch((e) => e)
+      expect(captured).toBeInstanceOf(ApiError)
+      expect((captured as ApiError).status).toBe(403)
+      expect((captured as ApiError).body).toBe('<Error><Code>SignatureDoesNotMatch</Code></Error>')
+    })
+
+    it('throws ApiConnectionError when the request fails', async () => {
+      vi.spyOn(globalThis, 'fetch').mockRejectedValue(new TypeError('fetch failed'))
+      await expect(api.upload(URL_TO_UPLOAD, 'content', 'text/plain')).rejects.toBeInstanceOf(
+        ApiConnectionError,
+      )
+    })
+  })
+
+  describe('deleteById', () => {
+    it('calls client.delete with /files/:id and resolves { success }', async () => {
+      vi.mocked(client.delete).mockResolvedValue({ success: true })
+      const result = await api.deleteById('file-1')
+      expect(client.delete).toHaveBeenCalledWith('/files/file-1', undefined)
+      expect(result).toEqual({ success: true })
+    })
+  })
+
+  describe('deprecated reads and update (no backend route)', () => {
+    it('still call the same paths', async () => {
+      await api.getById('file-1')
+      await api.getMany({ where: { id: 'file-1' } })
+      await api.updateById('file-1', { name: 'x' })
+      expect(client.get).toHaveBeenCalledWith('/files/file-1', undefined)
+      expect(client.get).toHaveBeenCalledWith(
+        `/files?query=${encodeURIComponent(JSON.stringify({ where: { id: 'file-1' } }))}`,
+        undefined,
+      )
+      expect(client.put).toHaveBeenCalledWith('/files/file-1', { name: 'x' }, undefined)
+    })
+  })
+})

package/src/apis/files/FilesApi.ts

@@ -1,9 +1,114 @@
 import type { ApiClient } from '../../core/ApiClient'
 import { BaseCrudApi } from '../../core/BaseCrudApi'
-import type { File, CreateFilePayload, UpdateFilePayload } from './types'
+import { requestExternal } from '../../core/requestExternal'
+import type { GetByIdQuery, ListQuery, Paginated } from '../../core/types'
+import type {
+  File,
+  CreateFilePayload,
+  UpdateFilePayload,
+  CreateToUploadPayload,
+  CreateToUploadResult,
+  DeleteFileResult,
+} from './types'
 
-export class FilesApi extends BaseCrudApi<File, CreateFilePayload, UpdateFilePayload> {
+/**
+ * Files of the account. The backend serves `POST /files` (the record only, no content),
+ * `POST /files/create-to-upload` (record + signed URL to upload the content), `POST
+ * /files/duplicate-file`, `DELETE /files/:id` and the signed download `GET
+ * /files/:accountId/:filename`; there is no list, read by id nor update.
+ */
+export class FilesApi extends BaseCrudApi<
+  File,
+  CreateFilePayload,
+  UpdateFilePayload,
+  ListQuery<File>,
+  DeleteFileResult
+> {
   constructor(client: ApiClient) {
     super(client, '/files')
   }
+
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getMany(
+    query: ListQuery<File> & { paginate: false },
+    headers?: Record<string, string>,
+  ): Promise<File[]>
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getMany(
+    query?: ListQuery<File> & { paginate?: true },
+    headers?: Record<string, string>,
+  ): Promise<Paginated<File>>
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getMany(
+    query?: ListQuery<File>,
+    headers?: Record<string, string>,
+  ): Promise<Paginated<File> | File[]>
+  override getMany(
+    query?: ListQuery<File>,
+    headers?: Record<string, string>,
+  ): Promise<Paginated<File> | File[]> {
+    return super.getMany(query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no GET /files, so this route answers 404. */
+  override getOne(query?: ListQuery<File>, headers?: Record<string, string>): Promise<File | null> {
+    return super.getOne(query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no GET /files/:id, so this route answers 404. */
+  override getById(
+    id: string,
+    query?: GetByIdQuery<File>,
+    headers?: Record<string, string>,
+  ): Promise<File> {
+    return super.getById(id, query, headers)
+  }
+
+  /** @deprecated Not served: the backend has no PUT /files/:id, so this route answers 404. */
+  override updateById(
+    id: string,
+    body: UpdateFilePayload,
+    headers?: Record<string, string>,
+  ): Promise<File> {
+    return super.updateById(id, body, headers)
+  }
+
+  /**
+   * Deletes a file. Resolves `{ success: true }`, also for an unknown id; a file of another
+   * account answers 403.
+   */
+  override deleteById(id: string, headers?: Record<string, string>): Promise<DeleteFileResult> {
+    return super.deleteById(id, headers)
+  }
+
+  /**
+   * Creates the record of a file and returns the signed URL to upload its content: send the
+   * content with {@link upload}. An audio that must be converted (a voice message for the
+   * connection) is sent in `base64` instead, and then no `urlToUpload` is returned. `name` and
+   * `mimetype` are required (500 without them; an audio without `name` is named `recording`).
+   */
+  createToUpload(
+    body: CreateToUploadPayload,
+    headers?: Record<string, string>,
+  ): Promise<CreateToUploadResult> {
+    return this.client.post<CreateToUploadResult, CreateToUploadPayload>(
+      `${this.basePath}/create-to-upload`,
+      body,
+      headers,
+    )
+  }
+
+  /**
+   * Uploads the content of a file to the `urlToUpload` returned by {@link createToUpload}. The URL
+   * is signed by the storage, so the request goes straight to it, without the API token (the
+   * storage refuses an `Authorization` header). `mimetype` must be the one sent to
+   * `createToUpload`. Sent through `client.requestExternal` (the global `fetch` for a client
+   * without it). A non-2xx answer of the storage throws `ApiError`.
+   */
+  async upload(urlToUpload: string, content: BodyInit, mimetype: string): Promise<void> {
+    const headers = { 'Content-Type': mimetype }
+    await (this.client.requestExternal
+      ? this.client.requestExternal('PUT', urlToUpload, content, headers)
+      : requestExternal('PUT', urlToUpload, content, headers))
+  }
 }

package/src/apis/files/types.ts

@@ -23,22 +23,32 @@ export type FileStorage =
 
 export type File = {
   id: string
+  /** Signed URL to download the content. */
   url: string
   name: string | null
+  /** Name of the file in the storage (`<id>.<extension>`). */
+  publicFilename: string | null
   checksum: string | null
   mimetype: string
   extension: string
-  isEncrypted: boolean
-  iv: string | null
-  attachedId: string | null
-  attachedType: string | null
-  storage: FileStorage
   data: FileData
   accountId: string
-  serviceId: string | null
   createdAt: string
   updatedAt: string
-  deletedAt: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  isEncrypted?: boolean
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  iv?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  attachedId?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  attachedType?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  storage?: FileStorage
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  serviceId?: string | null
+  /** @deprecated Never answered: the file transformer leaves it out. */
+  deletedAt?: string | null
 }
 
 export type CreateFilePayload = {
@@ -56,3 +66,34 @@ export type UpdateFilePayload = {
   attachedId?: string | null
   attachedType?: string | null
 }
+
+/** Body of `FilesApi.createToUpload`. */
+export type CreateToUploadPayload = {
+  /** File name (commas are replaced by spaces). Required, except for an audio. */
+  name?: string
+  mimetype: string
+  /** What the file is attached to, e.g. `'message.file'` (default), `'campaign.file'`, `'quickreply.file'`. */
+  attachedType?: string
+  /** Connection that will send the file (used to decide the audio conversion). */
+  serviceId?: string
+  /** Audio sent as a voice message (default `true`). */
+  isPtt?: boolean
+  /** Audio sent as a document, with no conversion (default `false`). */
+  sendAsDocument?: boolean
+  /** Content of an audio that must be converted (required in that case). */
+  base64?: string
+}
+
+/** Result of `FilesApi.createToUpload`. */
+export type CreateToUploadResult = {
+  /** Signed URL to send the content to (`FilesApi.upload`); absent when the audio was converted. */
+  urlToUpload?: string
+  id: string
+  name: string
+  mimetype: string
+}
+
+/** Result of `FilesApi.deleteById`. */
+export type DeleteFileResult = {
+  success: boolean
+}