@createiq/backend 1.0.0

package/dist/index.cjs

@@ -0,0 +1,4523 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  CancelError: () => CancelError,
+  CancelablePromise: () => CancelablePromise,
+  OpenAPI: () => OpenAPI,
+  acceptAllCounterpartyPositions: () => acceptAllCounterpartyPositions,
+  acceptAllCustodianTemplatePositions: () => acceptAllCustodianTemplatePositions,
+  acceptAllPositionsFromFork: () => acceptAllPositionsFromFork,
+  acceptAllPositionsFromPreviousVersion: () => acceptAllPositionsFromPreviousVersion,
+  acceptAllPresetPositions: () => acceptAllPresetPositions,
+  acceptCounterpartyPosition: () => acceptCounterpartyPosition,
+  acceptNestedAnswersCounterpartyPosition: () => acceptNestedAnswersCounterpartyPosition,
+  accountSummary: () => accountSummary,
+  addApprovalComment: () => addApprovalComment,
+  addComment: () => addComment,
+  addElectionApproval: () => addElectionApproval,
+  addElectionRejection: () => addElectionRejection,
+  addWatchers: () => addWatchers,
+  applyExtractedAnswers: () => applyExtractedAnswers,
+  approveFinalDocument: () => approveFinalDocument,
+  assignEntity: () => assignEntity,
+  assignToMe: () => assignToMe,
+  assignUser: () => assignUser,
+  auditTrailFilters: () => auditTrailFilters,
+  auditTrailForAccountAsExcel: () => auditTrailForAccountAsExcel,
+  auditTrailForAccountAsJson: () => auditTrailForAccountAsJson,
+  auditTrailForSubAccountAsExcel: () => auditTrailForSubAccountAsExcel,
+  auditTrailForSubAccountAsJson: () => auditTrailForSubAccountAsJson,
+  authPing: () => authPing,
+  breakingChanges: () => breakingChanges,
+  bulkSetsJobCount: () => bulkSetsJobCount,
+  cancel: () => cancel,
+  cancelExtraction: () => cancelExtraction,
+  cancelNegotiations: () => cancelNegotiations,
+  cancelNegotiationsJobCount: () => cancelNegotiationsJobCount,
+  changeSigningMode: () => changeSigningMode,
+  checkAuxiliaryDocument: () => checkAuxiliaryDocument,
+  checkOfflineNegotiatedDocument: () => checkOfflineNegotiatedDocument,
+  checkSignedExecutedVersion: () => checkSignedExecutedVersion,
+  checkSignedSignaturePagePdf: () => checkSignedSignaturePagePdf,
+  clonePreset: () => clonePreset,
+  confirm: () => confirm,
+  confirmExecutionVersion: () => confirmExecutionVersion,
+  consentCodeCallback: () => consentCodeCallback,
+  createAuditTrailJson: () => createAuditTrailJson,
+  createAuditTrailPdf: () => createAuditTrailPdf,
+  createAuditTrailXlsx: () => createAuditTrailXlsx,
+  createBulkSet: () => createBulkSet,
+  createGroup: () => createGroup,
+  createNegotiation: () => createNegotiation,
+  createPreset: () => createPreset,
+  createPresetAuditTrailJson: () => createPresetAuditTrailJson,
+  createPresetAuditTrailXlsx: () => createPresetAuditTrailXlsx,
+  createSignaturePagePdf: () => createSignaturePagePdf,
+  createSigningPack: () => createSigningPack,
+  deleteApprovalComment: () => deleteApprovalComment,
+  deleteAuxiliaryDocument: () => deleteAuxiliaryDocument,
+  deleteBulkSetAttachment: () => deleteBulkSetAttachment,
+  deleteComment: () => deleteComment,
+  deleteCoverNote: () => deleteCoverNote,
+  deleteDocumentDraftingNote: () => deleteDocumentDraftingNote,
+  deleteDocumentElectionDraftingNote: () => deleteDocumentElectionDraftingNote,
+  deleteDraftingNotesDocument: () => deleteDraftingNotesDocument,
+  deleteEntity: () => deleteEntity,
+  deleteExecutionAttachment: () => deleteExecutionAttachment,
+  deleteExternalAttachment: () => deleteExternalAttachment,
+  deleteGeneralCoverNote: () => deleteGeneralCoverNote,
+  deleteOfflineNegotiatedDocument: () => deleteOfflineNegotiatedDocument,
+  deletePreset: () => deletePreset,
+  deleteSignedExecutedVersion: () => deleteSignedExecutedVersion,
+  deleteSignedSignaturePageForParty: () => deleteSignedSignaturePageForParty,
+  documentRenderTemplate: () => documentRenderTemplate,
+  documentsFilter: () => documentsFilter,
+  downloadActiveNegotiationsReportAsExcel: () => downloadActiveNegotiationsReportAsExcel,
+  downloadDashboardReportAsExcel: () => downloadDashboardReportAsExcel,
+  downloadExecutedNegotiationsAsExcel: () => downloadExecutedNegotiationsAsExcel,
+  downloadNegotiation: () => downloadNegotiation,
+  downloadPostExecutionPack: () => downloadPostExecutionPack,
+  downloadPreExecutionCounterpartyNegotiation: () => downloadPreExecutionCounterpartyNegotiation,
+  downloadPreset: () => downloadPreset,
+  editAnswers: () => editAnswers,
+  editApprovalComment: () => editApprovalComment,
+  editDefaultAnswers: () => editDefaultAnswers,
+  emailPreferences: () => emailPreferences,
+  extendWindow: () => extendWindow,
+  forkNegotiation: () => forkNegotiation,
+  generateAndMaybeSendEnvelope: () => generateAndMaybeSendEnvelope,
+  getAccessibleNegotiation: () => getAccessibleNegotiation,
+  getAccountRelationshipSummaries: () => getAccountRelationshipSummaries,
+  getAllNegotiationCommentsForSubAccount: () => getAllNegotiationCommentsForSubAccount,
+  getAllVersions: () => getAllVersions,
+  getAmendDefaults: () => getAmendDefaults,
+  getAnnotatedOfflineNegotiatedDocument: () => getAnnotatedOfflineNegotiatedDocument,
+  getApprovalComments: () => getApprovalComments,
+  getApprovalHistory: () => getApprovalHistory,
+  getApprovalRound: () => getApprovalRound,
+  getAsCdm: () => getAsCdm,
+  getAuxiliaryDocument: () => getAuxiliaryDocument,
+  getBulkSet: () => getBulkSet,
+  getBulkSetAttachment: () => getBulkSetAttachment,
+  getChannelTimeline: () => getChannelTimeline,
+  getCommentSummary: () => getCommentSummary,
+  getComments: () => getComments,
+  getCompanyByEntityId: () => getCompanyByEntityId,
+  getDocument: () => getDocument,
+  getDocumentSchema: () => getDocumentSchema,
+  getDownloadActiveNegotiationsReportAsExcel: () => getDownloadActiveNegotiationsReportAsExcel,
+  getDownloadExecutedNegotiationsAsExcel: () => getDownloadExecutedNegotiationsAsExcel,
+  getDraftingNotes: () => getDraftingNotes,
+  getDraftingNotesDocument: () => getDraftingNotesDocument,
+  getElectionAnswer: () => getElectionAnswer,
+  getExecutedNegotiationSummary: () => getExecutedNegotiationSummary,
+  getExecutionAttachment: () => getExecutionAttachment,
+  getExternalAttachment: () => getExternalAttachment,
+  getExtractionResults: () => getExtractionResults,
+  getGroupNames: () => getGroupNames,
+  getLatestDocumentSchema: () => getLatestDocumentSchema,
+  getLegacyStatistics: () => getLegacyStatistics,
+  getMajorVersions: () => getMajorVersions,
+  getMultipleNestedAnswers: () => getMultipleNestedAnswers,
+  getNegotiation: () => getNegotiation,
+  getNegotiationDeltas: () => getNegotiationDeltas,
+  getNegotiationDraftingNotes: () => getNegotiationDraftingNotes,
+  getNegotiationESignStatus: () => getNegotiationESignStatus,
+  getNegotiationFilesSummary: () => getNegotiationFilesSummary,
+  getNegotiationsGroup: () => getNegotiationsGroup,
+  getNestedAnswers: () => getNestedAnswers,
+  getOfflineNegotiatedDocument: () => getOfflineNegotiatedDocument,
+  getOfflineNegotiatedDocumentAnnotations: () => getOfflineNegotiatedDocumentAnnotations,
+  getOriginalAnswersForForkNegotiation: () => getOriginalAnswersForForkNegotiation,
+  getOtherPartyAnswers: () => getOtherPartyAnswers,
+  getPartyAnswers: () => getPartyAnswers,
+  getPreset: () => getPreset,
+  getPreviousActiveUsers: () => getPreviousActiveUsers,
+  getPreviousMajorVersionsNestedAnswerElections: () => getPreviousMajorVersionsNestedAnswerElections,
+  getPreviousMajorVersionsNestedAnswerIds: () => getPreviousMajorVersionsNestedAnswerIds,
+  getProfile: () => getProfile,
+  getSecurityContext: () => getSecurityContext,
+  getSettings: () => getSettings,
+  getSignedExecutedVersion: () => getSignedExecutedVersion,
+  getSignedSignaturePagePdf: () => getSignedSignaturePagePdf,
+  getSsoConfig: () => getSsoConfig,
+  getStatistics: () => getStatistics,
+  getStatisticsOverview: () => getStatisticsOverview,
+  getSubAccount: () => getSubAccount,
+  getTimeline: () => getTimeline,
+  getTimelineActivity: () => getTimelineActivity,
+  getUserStatistics: () => getUserStatistics,
+  getUsers: () => getUsers,
+  getUsersForPicker: () => getUsersForPicker,
+  getWatchers: () => getWatchers,
+  getWindow: () => getWindow,
+  grantAllNegotiationsAccess: () => grantAllNegotiationsAccess,
+  grantNegotiationsAccess: () => grantNegotiationsAccess,
+  grantPresetsAccess: () => grantPresetsAccess,
+  grantWindow: () => grantWindow,
+  initialAnswers: () => initialAnswers,
+  listAdvisorsForWorkspace: () => listAdvisorsForWorkspace,
+  listAllPresetsForSubAccountV1: () => listAllPresetsForSubAccountV1,
+  listAllPresetsForSubAccountV2: () => listAllPresetsForSubAccountV2,
+  listBulkSets: () => listBulkSets,
+  listDocuments: () => listDocuments,
+  listDocumentsVersionsSummary: () => listDocumentsVersionsSummary,
+  listDocumentsWithPagination: () => listDocumentsWithPagination,
+  listEntities: () => listEntities,
+  listExecutionAttachments: () => listExecutionAttachments,
+  listExternalAttachments: () => listExternalAttachments,
+  listNegotiations: () => listNegotiations,
+  listPotentialNegotiationAdvisors: () => listPotentialNegotiationAdvisors,
+  listPotentialPresetAdvisors: () => listPotentialPresetAdvisors,
+  listPresets: () => listPresets,
+  listSubAccounts: () => listSubAccounts,
+  markActivityEventsAsViewed: () => markActivityEventsAsViewed,
+  markApprovalCommentsAsViewed: () => markApprovalCommentsAsViewed,
+  markAsFinal: () => markAsFinal,
+  markAsOffline: () => markAsOffline,
+  markCommentEventsAsViewed: () => markCommentEventsAsViewed,
+  markEventsAsViewed: () => markEventsAsViewed,
+  moveEntity: () => moveEntity,
+  negotiationForkHistory: () => negotiationForkHistory,
+  negotiationGetDocumentSchema: () => negotiationGetDocumentSchema,
+  negotiationRenderTemplate: () => negotiationRenderTemplate,
+  negotiationSendForApproval: () => negotiationSendForApproval,
+  negotiationsFilter: () => negotiationsFilter,
+  notifyOfDraft: () => notifyOfDraft,
+  obtainConsent: () => obtainConsent,
+  overrideApproveFinalDocument: () => overrideApproveFinalDocument,
+  overrideElectionApproval: () => overrideElectionApproval,
+  overrideElectionRejection: () => overrideElectionRejection,
+  overrideRejectFinalDocument: () => overrideRejectFinalDocument,
+  patchEmailPreferences: () => patchEmailPreferences,
+  presetEditAnswers: () => presetEditAnswers,
+  presetGetDocumentSchema: () => presetGetDocumentSchema,
+  presetGetMultipleNestedAnswers: () => presetGetMultipleNestedAnswers,
+  presetGetNestedAnswers: () => presetGetNestedAnswers,
+  presetRenderTemplate: () => presetRenderTemplate,
+  presetSendForApproval: () => presetSendForApproval,
+  presetSetElectionApproval: () => presetSetElectionApproval,
+  presetSetFinalApproval: () => presetSetFinalApproval,
+  presetSetMultipleNestedAnswers: () => presetSetMultipleNestedAnswers,
+  presetSetNestedAnswers: () => presetSetNestedAnswers,
+  presetSwapParties: () => presetSwapParties,
+  queueGenerateNegotiationDocumentJob: () => queueGenerateNegotiationDocumentJob,
+  rejectFinalDocument: () => rejectFinalDocument,
+  removeWatchers: () => removeWatchers,
+  renameExecutionAttachment: () => renameExecutionAttachment,
+  resetUserAnswers: () => resetUserAnswers,
+  retract: () => retract,
+  revertToAmending: () => revertToAmending,
+  revokeNegotiationsAccess: () => revokeNegotiationsAccess,
+  revokePresetsAccess: () => revokePresetsAccess,
+  revokeWindow: () => revokeWindow,
+  scheduleExtraction: () => scheduleExtraction,
+  schemaAvailableAsCdm: () => schemaAvailableAsCdm,
+  searchEntity: () => searchEntity,
+  sendBulkSetToCounterpartiesInitial: () => sendBulkSetToCounterpartiesInitial,
+  sendChaserEmail: () => sendChaserEmail,
+  sendDocumentApprovalReminder: () => sendDocumentApprovalReminder,
+  sendElectionApprovalReminder: () => sendElectionApprovalReminder,
+  sendGroupToCounterparty: () => sendGroupToCounterparty,
+  sendToCounterparty: () => sendToCounterparty,
+  sendToCounterpartyInitial: () => sendToCounterpartyInitial,
+  setAuxiliaryDocument: () => setAuxiliaryDocument,
+  setBulkSetAttachments: () => setBulkSetAttachments,
+  setCounterparties: () => setCounterparties,
+  setElectionApproval: () => setElectionApproval,
+  setExecutionAttachment: () => setExecutionAttachment,
+  setExecutionAttachments: () => setExecutionAttachments,
+  setExternalAttachment: () => setExternalAttachment,
+  setExternalAttachments: () => setExternalAttachments,
+  setFinalApproval: () => setFinalApproval,
+  setGeneralCoverNote: () => setGeneralCoverNote,
+  setMultipleNestedAnswers: () => setMultipleNestedAnswers,
+  setNestedAnswers: () => setNestedAnswers,
+  setOfflineNegotiatedDocument: () => setOfflineNegotiatedDocument,
+  setOwnerEntity: () => setOwnerEntity,
+  setPreset: () => setPreset,
+  setReceiverEntity: () => setReceiverEntity,
+  setSignedExecutedVersion: () => setSignedExecutedVersion,
+  setSignedSignaturePageForParty: () => setSignedSignaturePageForParty,
+  suggestGroupName: () => suggestGroupName,
+  swapParties: () => swapParties,
+  unsubscribe: () => unsubscribe,
+  updateAttachDocx: () => updateAttachDocx,
+  updateComment: () => updateComment,
+  updateCoverNote: () => updateCoverNote,
+  updateCustomFields: () => updateCustomFields,
+  updateDocumentDraftingNote: () => updateDocumentDraftingNote,
+  updateDocumentElectionDraftingNote: () => updateDocumentElectionDraftingNote,
+  updateDraftingNotes: () => updateDraftingNotes,
+  updateExtractionFeedback: () => updateExtractionFeedback,
+  updateGroupMembers: () => updateGroupMembers,
+  updateGroupName: () => updateGroupName,
+  updateMetadata: () => updateMetadata,
+  updateNegotiationsToMatch: () => updateNegotiationsToMatch,
+  updateSelectedElections: () => updateSelectedElections,
+  updateSubAccount: () => updateSubAccount,
+  updateUserAnswers: () => updateUserAnswers,
+  upgradePresetSchema: () => upgradePresetSchema,
+  upgradeSchema: () => upgradeSchema,
+  usersWithNegotiationAccess: () => usersWithNegotiationAccess,
+  validateDraftReceiverEmails: () => validateDraftReceiverEmails,
+  validateEntities: () => validateEntities,
+  version: () => version,
+  voidESignEnvelopeForNegotiation: () => voidESignEnvelopeForNegotiation
+});
+module.exports = __toCommonJS(index_exports);
+
+// client/core/ApiError.ts
+var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// client/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  _isResolved;
+  _isRejected;
+  _isCancelled;
+  cancelHandlers;
+  promise;
+  _resolve;
+  _reject;
+  constructor(executor) {
+    this._isResolved = false;
+    this._isRejected = false;
+    this._isCancelled = false;
+    this.cancelHandlers = [];
+    this.promise = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+      const onResolve = (value) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        if (this._resolve) this._resolve(value);
+      };
+      const onReject = (reason) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        if (this._reject) this._reject(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this.cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this._isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this._isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this._isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.promise.finally(onFinally);
+  }
+  cancel() {
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return;
+    }
+    this._isCancelled = true;
+    if (this.cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.cancelHandlers.length = 0;
+    if (this._reject) this._reject(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this._isCancelled;
+  }
+};
+
+// client/core/OpenAPI.ts
+var Interceptors = class {
+  _fns;
+  constructor() {
+    this._fns = [];
+  }
+  eject(fn) {
+    const index = this._fns.indexOf(fn);
+    if (index !== -1) {
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+    }
+  }
+  use(fn) {
+    this._fns = [...this._fns, fn];
+  }
+};
+var OpenAPI = {
+  BASE: "",
+  CREDENTIALS: "include",
+  ENCODE_PATH: void 0,
+  HEADERS: void 0,
+  PASSWORD: void 0,
+  TOKEN: void 0,
+  USERNAME: void 0,
+  VERSION: "1.1",
+  WITH_CREDENTIALS: false,
+  interceptors: {
+    request: new Interceptors(),
+    response: new Interceptors()
+  }
+};
+
+// client/core/request.ts
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return value instanceof Blob;
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const encodePair = (key, value) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (value instanceof Date) {
+      append(key, value.toISOString());
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => encodePair(key, v));
+    } else if (typeof value === "object") {
+      Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v));
+    } else {
+      append(key, value);
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => encodePair(key, value));
+  return qs.length ? `?${qs.join("&")}` : "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = config.BASE + path;
+  return options.query ? url + getQueryString(options.query) : url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([, value]) => value !== void 0 && value !== null).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    // @ts-ignore
+    resolve(options, config.TOKEN),
+    // @ts-ignore
+    resolve(options, config.USERNAME),
+    // @ts-ignore
+    resolve(options, config.PASSWORD),
+    // @ts-ignore
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([, value]) => value !== void 0 && value !== null).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+var getRequestBody = (options) => {
+  if (options.body !== void 0) {
+    if (options.mediaType?.includes("application/json") || options.mediaType?.includes("+json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  let request2 = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  for (const fn of config.interceptors.request._fns) {
+    request2 = await fn(request2);
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const binaryTypes = ["application/octet-stream", "application/pdf", "application/zip", "audio/", "image/", "video/"];
+        if (contentType.includes("application/json") || contentType.includes("+json")) {
+          return await response.json();
+        } else if (binaryTypes.some((type) => contentType.includes(type))) {
+          return await response.blob();
+        } else if (contentType.includes("multipart/form-data")) {
+          return await response.formData();
+        } else if (contentType.includes("text/")) {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "Im a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Content",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        let response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        for (const fn of config.interceptors.response._fns) {
+          response = await fn(response);
+        }
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        let transformedBody = responseBody;
+        if (options.responseTransformer && response.ok) {
+          transformedBody = await options.responseTransformer(responseBody);
+        }
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? transformedBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// client/sdk.gen.ts
+var authPing = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/authPing",
+    errors: {
+      401: "Your access token is not valid, or needs refreshing"
+    }
+  });
+};
+var version = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/version"
+  });
+};
+var accountSummary = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account",
+    errors: {
+      400: "Account does not exist"
+    }
+  });
+};
+var getSsoConfig = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account/sso"
+  });
+};
+var getSecurityContext = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/user/context"
+  });
+};
+var sendChaserEmail = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/sendChaserEmail",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "Invalid negotiation state or trying to send the email too soon",
+      404: "Negotiation or Sub-Account not found"
+    }
+  });
+};
+var unsubscribe = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/negotiations/{negotiationId}/muteNotifications",
+    path: {
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "The hash provided cannot be verified",
+      404: "Negotiation not found"
+    }
+  });
+};
+var getProfile = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/user/profile"
+  });
+};
+var getSettings = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account/settings",
+    errors: {
+      404: "Account not found"
+    }
+  });
+};
+var deleteEntity = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/account/entity/{entityId}",
+    path: {
+      entityId: data.entityId
+    },
+    errors: {
+      409: "Entity cannot be deleted as it is in use"
+    }
+  });
+};
+var getUsers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subaccount/{subAccountId}/users",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      includeSuperManagers: data.includeSuperManagers,
+      includeAdvisors: data.includeAdvisors
+    },
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var getUsersForPicker = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subaccount/{subAccountId}/usersForPicker",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      includeSuperManagers: data.includeSuperManagers,
+      includeAdvisors: data.includeAdvisors
+    },
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var listEntities = (data = {}) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account/entities",
+    query: {
+      query: data.query
+    }
+  });
+};
+var getCompanyByEntityId = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/entity/{entityId}",
+    path: {
+      entityId: data.entityId
+    },
+    errors: {
+      404: "Company not found"
+    }
+  });
+};
+var searchEntity = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/entity",
+    query: {
+      search: data.search
+    }
+  });
+};
+var validateEntities = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/entity/validate",
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var createPreset = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/presets",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Schema not found"
+    }
+  });
+};
+var listAllPresetsForSubAccountV1 = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/presets",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize,
+      orderBy: data.orderBy,
+      orderDirection: data.orderDirection,
+      filterApproved: data.filterApproved,
+      advisorRelationshipId: data.advisorRelationshipId,
+      accessibleToAdvisor: data.accessibleToAdvisor,
+      filterStage2: data.filterStage2,
+      query: data.query
+    }
+  });
+};
+var deletePreset = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/presets/{presetId}",
+    path: {
+      presetId: data.presetId
+    }
+  });
+};
+var getPreset = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}",
+    path: {
+      presetId: data.presetId
+    }
+  });
+};
+var presetEditAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/answers",
+    path: {
+      presetId: data.presetId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Preset or election not found"
+    }
+  });
+};
+var presetGetMultipleNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/presets/{presetId}/answers/nested/bulk",
+    path: {
+      presetId: data.presetId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Too many nested answers IDs passed",
+      404: "Preset not found"
+    }
+  });
+};
+var presetSetMultipleNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/answers/nested/bulk",
+    path: {
+      presetId: data.presetId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Too many nested answers IDs passed",
+      404: "Preset not found"
+    }
+  });
+};
+var presetGetNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}/answers/nested/{nestedAnswersId}",
+    path: {
+      presetId: data.presetId,
+      nestedAnswersId: data.nestedAnswersId
+    },
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var presetSetNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/answers/nested/{nestedAnswersId}",
+    path: {
+      presetId: data.presetId,
+      nestedAnswersId: data.nestedAnswersId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Preset or election not found"
+    }
+  });
+};
+var presetSwapParties = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/swapParties",
+    path: {
+      presetId: data.presetId
+    },
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var upgradePresetSchema = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/schema/upgrade",
+    path: {
+      presetId: data.presetId
+    },
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var updateMetadata = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/metadata",
+    path: {
+      presetId: data.presetId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var downloadPreset = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}/extension/{extension}",
+    path: {
+      presetId: data.presetId,
+      extension: data.extension
+    }
+  });
+};
+var listAllPresetsForSubAccountV2 = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v2/subAccounts/{subAccountId}/presets",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize,
+      orderBy: data.orderBy,
+      orderDirection: data.orderDirection,
+      filterApproved: data.filterApproved,
+      advisorRelationshipId: data.advisorRelationshipId,
+      accessibleToAdvisor: data.accessibleToAdvisor,
+      filterStage2: data.filterStage2,
+      query: data.query
+    }
+  });
+};
+var listPresets = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/documents/{documentId}/presets",
+    path: {
+      subAccountId: data.subAccountId,
+      documentId: data.documentId
+    },
+    query: {
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize,
+      orderBy: data.orderBy,
+      orderDirection: data.orderDirection,
+      filterApproved: data.filterApproved,
+      filterStage2: data.filterStage2
+    }
+  });
+};
+var presetSendForApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/approvals/sendForApproval",
+    path: {
+      presetId: data.presetId
+    },
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var clonePreset = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/presets/{presetId}/clone",
+    path: {
+      presetId: data.presetId
+    },
+    query: {
+      withApprovers: data.withApprovers
+    },
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var presetSetElectionApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/approvals/elections/{electionId}",
+    path: {
+      presetId: data.presetId,
+      electionId: data.electionId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Forbidden action in this state",
+      404: "Preset not found"
+    }
+  });
+};
+var presetSetFinalApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/presets/{presetId}/approvals/document",
+    path: {
+      presetId: data.presetId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var createPresetAuditTrailJson = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}/audit_trail/json",
+    path: {
+      presetId: data.presetId
+    }
+  });
+};
+var createPresetAuditTrailXlsx = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}/audit_trail/xlsx",
+    path: {
+      presetId: data.presetId
+    },
+    query: {
+      timeZone: data.timeZone
+    }
+  });
+};
+var listNegotiations = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      state: data.state,
+      status: data.status,
+      workflowType: data.workflowType,
+      userId: data.userId,
+      turn: data.turn,
+      staleFrom: data.staleFrom,
+      staleTo: data.staleTo,
+      groupId: data.groupId,
+      bulkSetIds: data.bulkSetIds,
+      jobStatus: data.jobStatus,
+      filters: data.filters,
+      query: data.query,
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize,
+      orderBy: data.orderBy,
+      orderDirection: data.orderDirection,
+      documentPublisherId: data.documentPublisherId,
+      excludedUiStates: data.excludedUiStates,
+      documentType: data.documentType,
+      myEntityName: data.myEntityName,
+      counterpartyEntityName: data.counterpartyEntityName,
+      inBulkSet: data.inBulkSet,
+      advisorRelationshipId: data.advisorRelationshipId,
+      accessibleToAdvisor: data.accessibleToAdvisor,
+      customReferenceId: data.customReferenceId,
+      displayReferenceId: data.displayReferenceId,
+      isForkedOrFork: data.isForkedOrFork,
+      approverName: data.approverName,
+      partyA: data.partyA,
+      partyB: data.partyB,
+      partyC: data.partyC,
+      partyAny: data.partyAny,
+      isTriparty: data.isTriparty,
+      isOffline: data.isOffline,
+      forkedFromOrTo: data.forkedFromOrTo
+    }
+  });
+};
+var createNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var setFinalApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var downloadDashboardReportAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      documentId: data.documentId,
+      timeZone: data.timeZone,
+      state: data.state,
+      status: data.status,
+      workflowType: data.workflowType,
+      userId: data.userId,
+      turn: data.turn,
+      staleFrom: data.staleFrom,
+      staleTo: data.staleTo,
+      groupId: data.groupId,
+      bulkSetIds: data.bulkSetIds,
+      jobStatus: data.jobStatus,
+      filters: data.filters,
+      query: data.query,
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize,
+      orderBy: data.orderBy,
+      orderDirection: data.orderDirection,
+      documentPublisherId: data.documentPublisherId,
+      excludedUiStates: data.excludedUiStates,
+      documentType: data.documentType,
+      myEntityName: data.myEntityName,
+      counterpartyEntityName: data.counterpartyEntityName,
+      inBulkSet: data.inBulkSet,
+      advisorRelationshipId: data.advisorRelationshipId,
+      accessibleToAdvisor: data.accessibleToAdvisor,
+      customReferenceId: data.customReferenceId,
+      displayReferenceId: data.displayReferenceId,
+      isForkedOrFork: data.isForkedOrFork,
+      approverName: data.approverName,
+      partyA: data.partyA,
+      partyB: data.partyB,
+      partyC: data.partyC,
+      partyAny: data.partyAny,
+      isTriparty: data.isTriparty,
+      isOffline: data.isOffline,
+      requestingFromContext: data.requestingFromContext,
+      forkedFromOrTo: data.forkedFromOrTo
+    }
+  });
+};
+var upgradeSchema = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/upgrade",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var breakingChanges = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/breaking_changes",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var getAccessibleNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/negotiations/{negotiationId}",
+    path: {
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var getNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var getExecutedNegotiationSummary = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/metadata",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getAsCdm = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/cdm",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "CDM not available for this negotiation",
+      404: "Negotiation not found"
+    }
+  });
+};
+var getDownloadExecutedNegotiationsAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/executed_negotiations/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      documentId: data.documentId,
+      timeZone: data.timeZone
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var downloadExecutedNegotiationsAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/executed_negotiations/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getDownloadActiveNegotiationsReportAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/analytics/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      documentId: data.documentId,
+      timeZone: data.timeZone
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var downloadActiveNegotiationsReportAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/analytics/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var downloadNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extension/{extension}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      extension: data.extension
+    },
+    query: {
+      includeSignaturePages: data.includeSignaturePages,
+      isLockedDocx: data.isLockedDocx,
+      includeFormFields: data.includeFormFields
+    }
+  });
+};
+var downloadPreExecutionCounterpartyNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/parties/{counterpartyId}/extension/{extension}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      counterpartyId: data.counterpartyId,
+      extension: data.extension
+    }
+  });
+};
+var getSignedExecutedVersion = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executed_version",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Missing document"
+    }
+  });
+};
+var setSignedExecutedVersion = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executed_version",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/pdf",
+    errors: {
+      400: "The negotiation is not at the Review & Sign stage or there is already an executed version uploaded",
+      403: "The negotiation does not support uploading executed versions",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var deleteSignedExecutedVersion = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executed_version",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "The negotiation does not support uploading executed versions"
+    }
+  });
+};
+var checkSignedExecutedVersion = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executed_version/exists",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "The negotiation has not yet been agreed"
+    }
+  });
+};
+var getNegotiationFilesSummary = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/negotiationFiles/summary",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "No negotiation"
+    }
+  });
+};
+var createAuditTrailXlsx = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/audit_trail/xlsx",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      timeZone: data.timeZone
+    }
+  });
+};
+var createAuditTrailPdf = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/audit_trail/pdf",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      timeZone: data.timeZone
+    }
+  });
+};
+var createAuditTrailJson = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/audit_trail/json",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var createSigningPack = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signingPack",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var downloadPostExecutionPack = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/postExecutionPack",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      timeZone: data.timeZone
+    }
+  });
+};
+var createSignaturePagePdf = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signature/{pageId}/pdf",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      pageId: data.pageId
+    }
+  });
+};
+var getSignedSignaturePagePdf = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signature/{sigPageId}/signed/pdf",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      sigPageId: data.sigPageId
+    },
+    errors: {
+      400: "Invalid state",
+      404: "Missing document"
+    }
+  });
+};
+var checkSignedSignaturePagePdf = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signature/signed/pdf/exists",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "Invalid state"
+    }
+  });
+};
+var setSignedSignaturePageForParty = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signature/{pageId}/signed/pdf",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      pageId: data.pageId
+    },
+    body: data.requestBody,
+    mediaType: "application/pdf"
+  });
+};
+var deleteSignedSignaturePageForParty = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signature/{pageId}/signed/pdf",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      pageId: data.pageId
+    }
+  });
+};
+var getAuxiliaryDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/auxiliary_document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Missing document"
+    }
+  });
+};
+var setAuxiliaryDocument = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/auxiliary_document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/pdf",
+    errors: {
+      400: "The negotiation is not at the Review & Sign stage or there is already an auxiliary document uploaded",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var deleteAuxiliaryDocument = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/auxiliary_document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var checkAuxiliaryDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/auxiliary_document/exists",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Auxiliary document upload is not enabled for the document type or the negotiation has not yet been agreed"
+    }
+  });
+};
+var getOfflineNegotiatedDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/offline_negotiated_document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Missing document"
+    }
+  });
+};
+var setOfflineNegotiatedDocument = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/offline_negotiated_document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/pdf",
+    errors: {
+      400: "The negotiation is not offline, is not at the Amending stage, or there is already an offline negotiated document uploaded",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var deleteOfflineNegotiatedDocument = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/offline_negotiated_document",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var getAnnotatedOfflineNegotiatedDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/offline_negotiated_document/annotated",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "Extraction has not yet completed",
+      404: "Missing document"
+    }
+  });
+};
+var getOfflineNegotiatedDocumentAnnotations = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/offline_negotiated_document/annotations",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "Extraction has not yet completed",
+      404: "Missing document"
+    }
+  });
+};
+var checkOfflineNegotiatedDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/offline_negotiated_document/exists",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Extraction is not enabled for the document type or the negotiation is not offline"
+    }
+  });
+};
+var listDocuments = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents",
+    query: {
+      state: data.state,
+      subAccountId: data.subAccountId,
+      documentPublisherId: data.documentPublisherId,
+      documentPackIds: data.documentPackIds,
+      templateContains: data.templateContains,
+      supportsBulkUpload: data.supportsBulkUpload,
+      hasNegotiations: data.hasNegotiations,
+      year: data.year,
+      abbreviation: data.abbreviation,
+      law: data.law,
+      publisherName: data.publisherName,
+      query: data.query,
+      orderBy: data.orderBy,
+      onlyWithSchema: data.onlyWithSchema,
+      includeTransitive: data.includeTransitive
+    }
+  });
+};
+var listDocumentsWithPagination = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documentsWithPaging",
+    query: {
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize,
+      state: data.state,
+      subAccountId: data.subAccountId,
+      documentPublisherId: data.documentPublisherId,
+      documentPackIds: data.documentPackIds,
+      templateContains: data.templateContains,
+      supportsBulkUpload: data.supportsBulkUpload,
+      hasNegotiations: data.hasNegotiations,
+      year: data.year,
+      abbreviation: data.abbreviation,
+      law: data.law,
+      publisherName: data.publisherName,
+      query: data.query,
+      orderBy: data.orderBy,
+      onlyWithSchema: data.onlyWithSchema,
+      includeTransitive: data.includeTransitive
+    }
+  });
+};
+var listDocumentsVersionsSummary = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/versions",
+    query: {
+      state: data.state,
+      subAccountId: data.subAccountId,
+      documentPublisherId: data.documentPublisherId,
+      templateContains: data.templateContains,
+      supportsBulkUpload: data.supportsBulkUpload,
+      hasNegotiations: data.hasNegotiations,
+      year: data.year,
+      abbreviation: data.abbreviation,
+      law: data.law,
+      publisherName: data.publisherName,
+      documentPackIds: data.documentPackIds,
+      query: data.query,
+      orderBy: data.orderBy
+    }
+  });
+};
+var getDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}",
+    path: {
+      documentId: data.documentId
+    },
+    errors: {
+      404: "Schema not found"
+    }
+  });
+};
+var getDocumentSchema = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}/schemas/{version}",
+    path: {
+      documentId: data.documentId,
+      version: data.version
+    },
+    query: {
+      restrictedTo: data.restrictedTo
+    },
+    errors: {
+      404: "Schema not found"
+    }
+  });
+};
+var schemaAvailableAsCdm = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}/schemas/{version}/availableAsCDM",
+    path: {
+      documentId: data.documentId,
+      version: data.version
+    },
+    errors: {
+      404: "Document or schema version not found"
+    }
+  });
+};
+var documentRenderTemplate = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}/schemas/{version}/preview",
+    path: {
+      documentId: data.documentId,
+      version: data.version
+    },
+    errors: {
+      404: "Document or schema version not found"
+    }
+  });
+};
+var getAmendDefaults = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}/schemas/{version}/amendDefaults",
+    path: {
+      documentId: data.documentId,
+      version: data.version
+    },
+    errors: {
+      404: "Document or schema version not found"
+    }
+  });
+};
+var getLatestDocumentSchema = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}/latest_schema",
+    path: {
+      documentId: data.documentId
+    },
+    errors: {
+      404: "Document or schema not found"
+    }
+  });
+};
+var forkNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/restate",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "The negotiation specified cannot be restated.",
+      404: "Negotiation or sub account not found"
+    }
+  });
+};
+var negotiationForkHistory = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/restatementHistory",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "A negotiation in the history is missing",
+      404: "Negotiation or sub account not found"
+    }
+  });
+};
+var getOriginalAnswersForForkNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{forkedNegotiationId}/originalAnswers",
+    path: {
+      subAccountId: data.subAccountId,
+      forkedNegotiationId: data.forkedNegotiationId
+    },
+    errors: {
+      404: "Negotiation or sub account not found"
+    }
+  });
+};
+var notifyOfDraft = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/notifyOfDraft",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var updateCustomFields = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/customFields",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var markAsFinal = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/markAsFinal",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var editAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var editDefaultAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/defaults",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Initial answers have already been set",
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var acceptAllCounterpartyPositions = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/acceptCpPosition/{partyId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      partyId: data.partyId
+    },
+    query: {
+      excludeNestedAnswers: data.excludeNestedAnswers
+    },
+    errors: {
+      400: "The counterparty's position is not available",
+      404: "Negotiation not found"
+    }
+  });
+};
+var acceptAllPresetPositions = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/acceptPresetPosition",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "The preset's position is not available",
+      404: "Negotiation not found"
+    }
+  });
+};
+var acceptAllCustodianTemplatePositions = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/acceptCustodianTemplatePosition",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "The custodian template position is not available",
+      404: "Negotiation not found"
+    }
+  });
+};
+var acceptAllPositionsFromPreviousVersion = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/acceptPreviousPosition/{version}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      version: data.version
+    },
+    errors: {
+      400: "The previous version is not available",
+      404: "Negotiation not found"
+    }
+  });
+};
+var acceptAllPositionsFromFork = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/acceptOriginalPosition/{forkedNegotiationId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      forkedNegotiationId: data.forkedNegotiationId
+    },
+    errors: {
+      400: "The original fork position is not available for the specified version",
+      404: "Negotiation not found"
+    }
+  });
+};
+var getElectionAnswer = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/elections/{electionId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    query: {
+      type: data.type
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getMajorVersions = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/parties/{partyId}/versions",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      partyId: data.partyId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getAllVersions = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/parties/{partyId}/versions/all",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      partyId: data.partyId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getOtherPartyAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/parties/{counterpartyId}/versions/{version}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      counterpartyId: data.counterpartyId,
+      version: data.version
+    },
+    errors: {
+      404: "Party answers not found of the party id for the specified version  or negotiation not found"
+    }
+  });
+};
+var getPartyAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/versions/{version}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      version: data.version
+    },
+    errors: {
+      404: "Party answers not found for the specified version or negotiation not found"
+    }
+  });
+};
+var acceptCounterpartyPosition = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/elections/{electionId}/acceptCpPosition/{partyId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId,
+      partyId: data.partyId
+    },
+    query: {
+      excludeNestedAnswers: data.excludeNestedAnswers
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getMultipleNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/nested/bulk",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Too many nested answers IDs passed",
+      404: "Negotiation not found"
+    }
+  });
+};
+var setMultipleNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/nested/bulk",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Too many nested answers IDs passed",
+      404: "Negotiation not found"
+    }
+  });
+};
+var getNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/nested/{nestedAnswersId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      nestedAnswersId: data.nestedAnswersId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var setNestedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/nested/{nestedAnswersId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      nestedAnswersId: data.nestedAnswersId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getPreviousMajorVersionsNestedAnswerElections = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/nested/{nestedAnswersId}/previousElections",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      nestedAnswersId: data.nestedAnswersId
+    },
+    errors: {
+      403: "Negotiation not in amending state",
+      404: "No previous versions found"
+    }
+  });
+};
+var getPreviousMajorVersionsNestedAnswerIds = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/elections/{electionId}/previousAnswers",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    errors: {
+      403: "Negotiation not in amending state",
+      404: "No previous versions found"
+    }
+  });
+};
+var acceptNestedAnswersCounterpartyPosition = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/answers/nested/{nestedAnswersId}/acceptCpPosition/{partyId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      nestedAnswersId: data.nestedAnswersId,
+      partyId: data.partyId
+    },
+    errors: {
+      404: "Negotiation, nested answers ID or party not found"
+    }
+  });
+};
+var initialAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/initialAnswers",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var assignToMe = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/owner/myself",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var assignUser = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/owner/{userId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      userId: data.userId
+    },
+    errors: {
+      400: "Invalid user",
+      404: "Negotiation or user not found"
+    }
+  });
+};
+var getPreviousActiveUsers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/previousActiveUsers",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "Invalid user",
+      404: "Negotiation not found"
+    }
+  });
+};
+var setCounterparties = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/counterparties",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      strictLEI: data.strictLei
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Invalid or incomplete answers",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var getExternalAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/attachment/{fileName}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      fileName: data.fileName
+    },
+    errors: {
+      404: "Missing document"
+    }
+  });
+};
+var deleteExternalAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/attachment/{fileName}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      fileName: data.fileName
+    }
+  });
+};
+var listExternalAttachments = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/attachment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Invite attachment upload is not enabled for the document type"
+    }
+  });
+};
+var setExternalAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/attachment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/octet-stream",
+    errors: {
+      400: "The file is too large or would exceed the maximum total size for all files, or the negotiation is not currently in draft",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var setExternalAttachments = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/attachment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    formData: data.formData,
+    mediaType: "multipart/form-data",
+    errors: {
+      400: "The file(s) are too large or would exceed the maximum total size for all files, or the negotiation is not currently in draft",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var getExecutionAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executionAttachment/{fileName}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      fileName: data.fileName
+    },
+    errors: {
+      404: "Missing document"
+    }
+  });
+};
+var deleteExecutionAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executionAttachment/{fileName}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      fileName: data.fileName
+    }
+  });
+};
+var listExecutionAttachments = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executionAttachment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Execution attachment upload is not enabled for the document type"
+    }
+  });
+};
+var setExecutionAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executionAttachment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/pdf",
+    errors: {
+      400: "The file is too large or would exceed the maximum total size for all execution files, or the negotiation is not currently in ExecutionAgreed",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var setExecutionAttachments = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executionAttachment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    formData: data.formData,
+    mediaType: "multipart/form-data",
+    errors: {
+      400: "The file(s) are too large or would exceed the maximum total size for all execution files, or the negotiation is not currently in ExecutionAgreed.",
+      404: "The negotiation was not found"
+    }
+  });
+};
+var renameExecutionAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "PATCH",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/executionAttachment/{oldFileName}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      oldFileName: data.oldFileName
+    },
+    errors: {
+      400: "New filename is invalid",
+      404: "Old filename not found"
+    }
+  });
+};
+var setOwnerEntity = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/owner",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: "Invalid or incomplete answers",
+      404: "Negotiation not found",
+      409: "Could not save new version",
+      422: "Counterparty email address required"
+    }
+  });
+};
+var setReceiverEntity = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/entities",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var setPreset = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/preset",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or preset not found"
+    }
+  });
+};
+var swapParties = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/swapParties",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Forbidden action in this state",
+      404: "Negotiation not found"
+    }
+  });
+};
+var approveFinalDocument = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/document/approve",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "action not permitted (negotiation is in wrong state)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var overrideApproveFinalDocument = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/document/approve/override",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "action not permitted (negotiation is in wrong state)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var rejectFinalDocument = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/document/reject",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "action not permitted (negotiation is in wrong state)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var overrideRejectFinalDocument = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/document/reject/override",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "action not permitted (negotiation is in wrong state)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var sendToCounterparty = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/sendToCounterparty",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "No counterparty is configured",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var setGeneralCoverNote = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/coverNote",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var deleteGeneralCoverNote = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/coverNote",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var negotiationSendForApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/sendForApproval",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Action not permitted (negotiation is in wrong state)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var changeSigningMode = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signingMode",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Action not permitted (negotiation is in wrong state)",
+      404: "Negotiation not found"
+    }
+  });
+};
+var setElectionApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/elections/{electionId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var sendDocumentApprovalReminder = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/document/reminder",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "There is no pending approval or approval sent date",
+      404: "Negotiation or sub-account not found"
+    }
+  });
+};
+var sendElectionApprovalReminder = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/elections/{electionId}/reminder",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    errors: {
+      400: "There is no pending approval",
+      404: "Negotiation, sub-account or election id not found"
+    }
+  });
+};
+var addElectionApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/elections/{electionId}/approve",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Action not permitted (negotiation is in the wrong state or you do not have permission)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var addElectionRejection = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/elections/{electionId}/reject",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Action not permitted (negotiation is in the wrong state or you do not have permission)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var overrideElectionApproval = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/elections/{electionId}/approve/override",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Action not permitted (negotiation is in the wrong state or you do not have permission)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var overrideElectionRejection = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/elections/{electionId}/reject/override",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      electionId: data.electionId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Action not permitted (negotiation is in the wrong state or you do not have permission)",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var getApprovalHistory = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/history",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var getApprovalRound = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/{roundId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      roundId: data.roundId
+    }
+  });
+};
+var addApprovalComment = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/comment",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Comment value is empty"
+    }
+  });
+};
+var editApprovalComment = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/comment/{approvalCommentId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      approvalCommentId: data.approvalCommentId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Comment value is empty"
+    }
+  });
+};
+var deleteApprovalComment = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/comment/{approvalCommentId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      approvalCommentId: data.approvalCommentId
+    },
+    errors: {
+      403: "Action not permitted (user does not have permission)"
+    }
+  });
+};
+var getApprovalComments = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/comments/all",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var markApprovalCommentsAsViewed = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/approvals/comments/markAsRead",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var sendToCounterpartyInitial = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/sendToCounterparty/initial",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "No counterparty is configured",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var markAsOffline = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/markAsOffline",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "No counterparty is configured",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var confirm = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/confirm",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "Invalid, incomplete or mismatching answers",
+      404: "Negotiation not found",
+      409: "Could not save new version"
+    }
+  });
+};
+var cancel = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/cancel",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var cancelNegotiations = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/cancelNegotiations",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var retract = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/retract",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var confirmExecutionVersion = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/confirmExecutionVersion",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var revertToAmending = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/revertToAmending",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getComments = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/comments",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getCommentSummary = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/commentSummary",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      summaryContext: data.summaryContext,
+      unreadOnly: data.unreadOnly
+    },
+    errors: {
+      400: "The specified summaryContext is not available for this negotiation.",
+      403: "The AI comment summerisation feature has not been enabled for this account.",
+      404: "Negotiation not found or No comments to summarise.",
+      503: "Unable to fetch a summary, the generated summary may have been discarded if it contained inappropriate content."
+    }
+  });
+};
+var getTimelineActivity = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/activities",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      orderDirection: data.orderDirection
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getChannelTimeline = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/{channel}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      channel: data.channel
+    },
+    query: {
+      orderDirection: data.orderDirection
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var getTimeline = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      orderDirection: data.orderDirection
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var markEventsAsViewed = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var markActivityEventsAsViewed = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/activities/markAsRead",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var markCommentEventsAsViewed = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/comments/markAsRead",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var addComment = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/{channel}/comments",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      channel: data.channel
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var queueGenerateNegotiationDocumentJob = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/generateDocument",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var updateComment = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/{channel}/comments/{eventId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      eventId: data.eventId,
+      channel: data.channel
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var deleteComment = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/timeline/{channel}/comments/{eventId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId,
+      eventId: data.eventId,
+      channel: data.channel
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var updateSubAccount = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var getSubAccount = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var listSubAccounts = (data = {}) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts",
+    query: {
+      minimal: data.minimal,
+      subAccountName: data.subAccountName
+    }
+  });
+};
+var getLegacyStatistics = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/statistics",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      documentPublisherId: data.documentPublisherId
+    },
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var getStatistics = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v2/subAccounts/{subAccountId}/statistics",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      documentPublisherId: data.documentPublisherId,
+      isDraft: data.isDraft,
+      isCompleted: data.isCompleted,
+      isCancelled: data.isCancelled,
+      isAmendAndRestate: data.isAmendAndRestate,
+      isTriparty: data.isTriparty,
+      isOffline: data.isOffline,
+      isAdvisorAccessible: data.isAdvisorAccessible,
+      isConfirmedTemplate: data.isConfirmedTemplate,
+      creationDateFrom: data.creationDateFrom,
+      creationDateTo: data.creationDateTo,
+      advisorRelationshipId: data.advisorRelationshipId
+    },
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var getUserStatistics = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v2/subAccounts/{subAccountId}/statistics/users/{userId}",
+    path: {
+      subAccountId: data.subAccountId,
+      userId: data.userId
+    },
+    query: {
+      documentPublisherId: data.documentPublisherId,
+      isDraft: data.isDraft,
+      isCompleted: data.isCompleted,
+      isCancelled: data.isCancelled,
+      isAmendAndRestate: data.isAmendAndRestate,
+      isTriparty: data.isTriparty,
+      isOffline: data.isOffline,
+      isAdvisorAccessible: data.isAdvisorAccessible,
+      isConfirmedTemplate: data.isConfirmedTemplate,
+      creationDateFrom: data.creationDateFrom,
+      creationDateTo: data.creationDateTo,
+      advisorRelationshipId: data.advisorRelationshipId
+    },
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var getStatisticsOverview = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v2/subAccounts/{subAccountId}/statisticsOverview",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    errors: {
+      404: "Sub-account not found"
+    }
+  });
+};
+var assignEntity = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/entity",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Subaccount or Entity not found",
+      409: "Entity is already assigned to a subaccount in this account"
+    }
+  });
+};
+var moveEntity = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/entity/{entityId}/move",
+    path: {
+      entityId: data.entityId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Entity could not be found on the Sub-Account",
+      419: "Entity cannot be moved from and to the same Sub-Account"
+    }
+  });
+};
+var auditTrailForSubAccountAsJson = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/audit_trail/json",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      yearMonths: data.yearMonths
+    }
+  });
+};
+var auditTrailForSubAccountAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/audit_trail/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      yearMonths: data.yearMonths
+    }
+  });
+};
+var auditTrailFilters = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account/audit_trail/filters"
+  });
+};
+var auditTrailForAccountAsJson = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account/audit_trail/json",
+    query: {
+      includeSubAccountEvents: data.includeSubAccountEvents,
+      yearMonths: data.yearMonths
+    }
+  });
+};
+var auditTrailForAccountAsExcel = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/account/audit_trail/xlsx",
+    query: {
+      includeSubAccountEvents: data.includeSubAccountEvents,
+      yearMonths: data.yearMonths
+    }
+  });
+};
+var emailPreferences = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/emailPreferences"
+  });
+};
+var patchEmailPreferences = (data) => {
+  return request(OpenAPI, {
+    method: "PATCH",
+    url: "/api/v1/emailPreferences",
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var listPotentialNegotiationAdvisors = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/negotiations/{negotiationId}/potentialAdvisors",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var listPotentialPresetAdvisors = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/presets/{presetId}/potentialAdvisors",
+    path: {
+      subAccountId: data.subAccountId,
+      presetId: data.presetId
+    }
+  });
+};
+var getAccountRelationshipSummaries = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/advisor/accounts/relationships/summary",
+    errors: {
+      403: "The request is from advisor"
+    }
+  });
+};
+var listAdvisorsForWorkspace = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/listAdvisors",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var grantNegotiationsAccess = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/relationships/{relationshipId}/negotiations",
+    path: {
+      relationshipId: data.relationshipId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var revokeNegotiationsAccess = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/relationships/{relationshipId}/negotiations",
+    path: {
+      relationshipId: data.relationshipId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var grantAllNegotiationsAccess = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/relationships/{relationshipId}/negotiations/all",
+    path: {
+      relationshipId: data.relationshipId,
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var grantPresetsAccess = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/relationships/{relationshipId}/presets",
+    path: {
+      relationshipId: data.relationshipId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var revokePresetsAccess = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/advisor/subAccounts/{subAccountId}/relationships/{relationshipId}/presets",
+    path: {
+      relationshipId: data.relationshipId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var createGroup = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var getGroupNames = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var updateGroupName = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/{negotiationGroupId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationGroupId: data.negotiationGroupId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation group not found"
+    }
+  });
+};
+var getNegotiationDeltas = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/deltas/calculate",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var updateNegotiationsToMatch = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/deltas/apply",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      409: "One or more negotiations could not be updated, so none were updated."
+    }
+  });
+};
+var suggestGroupName = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/nameSuggestions",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      desiredName: data.desiredName
+    }
+  });
+};
+var updateGroupMembers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/{negotiationGroupId}/members",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationGroupId: data.negotiationGroupId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation group not found"
+    }
+  });
+};
+var getNegotiationsGroup = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/{negotiationGroupId}/negotiations",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationGroupId: data.negotiationGroupId
+    }
+  });
+};
+var sendGroupToCounterparty = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiationGroups/{negotiationGroupId}/sendToCounterparty",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationGroupId: data.negotiationGroupId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "Unauthorised access of the negotiation group and the Sub-Account",
+      409: "Could not save new version"
+    }
+  });
+};
+var createBulkSet = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/bulkSets",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var listBulkSets = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/bulkSets",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var getBulkSet = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/bulkSets/{bulkSetId}",
+    path: {
+      bulkSetId: data.bulkSetId
+    }
+  });
+};
+var updateAttachDocx = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/bulkSets/{bulkSetId}/updateAttachDocx",
+    path: {
+      bulkSetId: data.bulkSetId
+    }
+  });
+};
+var updateCoverNote = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/bulkSets/{bulkSetId}/coverNote",
+    path: {
+      bulkSetId: data.bulkSetId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var deleteCoverNote = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/bulkSets/{bulkSetId}/coverNote",
+    path: {
+      bulkSetId: data.bulkSetId
+    }
+  });
+};
+var bulkSetsJobCount = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/bulkSets/count",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var cancelNegotiationsJobCount = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/cancelNegotiationJobCount",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var sendBulkSetToCounterpartiesInitial = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/bulkSets/{bulkSetId}/sendToCounterparty/initial",
+    path: {
+      bulkSetId: data.bulkSetId
+    }
+  });
+};
+var setBulkSetAttachments = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/bulkSets/{bulkSetId}/attachment",
+    path: {
+      bulkSetId: data.bulkSetId
+    },
+    formData: data.formData,
+    mediaType: "multipart/form-data",
+    errors: {
+      400: "The file(s) are too large or would exceed the maximum total size for all files",
+      404: "The bulk set was not found"
+    }
+  });
+};
+var deleteBulkSetAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/bulkSets/{bulkSetId}/attachment/{fileName}",
+    path: {
+      bulkSetId: data.bulkSetId,
+      fileName: data.fileName
+    }
+  });
+};
+var getBulkSetAttachment = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/bulkSets/{bulkSetId}/attachment/{fileName}",
+    path: {
+      bulkSetId: data.bulkSetId,
+      fileName: data.fileName
+    }
+  });
+};
+var validateDraftReceiverEmails = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/bulkSets/validateEmails",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json"
+  });
+};
+var getDraftingNotes = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNotes",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var updateDraftingNotes = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNotes",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId
+    },
+    errors: {
+      400: "Update drafting notes failed"
+    }
+  });
+};
+var deleteDraftingNotesDocument = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNotes",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var updateDocumentDraftingNote = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNote/noteType/{noteType}",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId,
+      noteType: data.noteType
+    },
+    errors: {
+      400: "Drafting note update failed"
+    }
+  });
+};
+var deleteDocumentDraftingNote = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNote/noteType/{noteType}",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId,
+      noteType: data.noteType
+    },
+    errors: {
+      400: "Deletion of drafting note failed",
+      404: "No document draftinmg note exist for the specified type"
+    }
+  });
+};
+var updateDocumentElectionDraftingNote = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNote/elections/{electionId}/noteType/{noteType}",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId,
+      electionId: data.electionId,
+      noteType: data.noteType
+    },
+    errors: {
+      400: "Drafting note update failed"
+    }
+  });
+};
+var deleteDocumentElectionDraftingNote = (data) => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/documents/{documentId}/subAccounts/{subAccountId}/draftingNote/elections/{electionId}/noteType/{noteType}",
+    path: {
+      documentId: data.documentId,
+      subAccountId: data.subAccountId,
+      electionId: data.electionId,
+      noteType: data.noteType
+    },
+    errors: {
+      400: "Deletion of drafting note failed",
+      404: "No document draftinmg note exist for the specified type"
+    }
+  });
+};
+var getNegotiationDraftingNotes = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/negotiationDraftingNotes",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var getDraftingNotesDocument = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/draftingNotes",
+    path: {
+      subAccountId: data.subAccountId
+    }
+  });
+};
+var obtainConsent = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/docusign/connect",
+    errors: {
+      308: "Redirects user to the DocuSign consent form"
+    }
+  });
+};
+var getNegotiationESignStatus = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/docusign/status/subAccounts/{subAccountId}/negotiations/{negotiationId}",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    }
+  });
+};
+var consentCodeCallback = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/docusign/redirectCodeCallback",
+    errors: {
+      308: "Redirects the user back to the negotiation signing page"
+    }
+  });
+};
+var generateAndMaybeSendEnvelope = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/signWithDocuSign",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "DocuSign API errors"
+    }
+  });
+};
+var voidESignEnvelopeForNegotiation = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/esign/{subAccountId}/negotiations/{negotiationId}/cancelSession",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      400: "DocuSign API errors"
+    }
+  });
+};
+var usersWithNegotiationAccess = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/users",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    query: {
+      potentialApproversOnly: data.potentialApproversOnly
+    }
+  });
+};
+var negotiationRenderTemplate = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/preview",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Negotiation not found"
+    }
+  });
+};
+var presetRenderTemplate = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}/preview",
+    path: {
+      presetId: data.presetId
+    },
+    errors: {
+      404: "Preset not found"
+    }
+  });
+};
+var getAllNegotiationCommentsForSubAccount = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/comments/xlsx",
+    path: {
+      subAccountId: data.subAccountId
+    },
+    query: {
+      yearMonths: data.yearMonths
+    }
+  });
+};
+var getWatchers = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/watchers",
+    path: {
+      negotiationId: data.negotiationId,
+      subAccountId: data.subAccountId
+    },
+    errors: {
+      403: "You do not have access to the specified sub account"
+    }
+  });
+};
+var addWatchers = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/watchers",
+    path: {
+      negotiationId: data.negotiationId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "You do not have access to the specified sub account"
+    }
+  });
+};
+var removeWatchers = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/removeWatchers",
+    path: {
+      negotiationId: data.negotiationId,
+      subAccountId: data.subAccountId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: "You do not have access to the specified sub account"
+    }
+  });
+};
+var negotiationsFilter = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/filters/{filter}",
+    path: {
+      subAccountId: data.subAccountId,
+      filter: data.filter
+    },
+    query: {
+      query: data.query,
+      searchContext: data.searchContext,
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize
+    },
+    errors: {
+      403: "You do not have access to the specified sub account"
+    }
+  });
+};
+var negotiationGetDocumentSchema = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/schema",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Schema not found"
+    }
+  });
+};
+var presetGetDocumentSchema = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/presets/{presetId}/schema",
+    path: {
+      presetId: data.presetId
+    },
+    errors: {
+      404: "Schema not found"
+    }
+  });
+};
+var documentsFilter = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/documents/filters/{filter}",
+    path: {
+      subAccountId: data.subAccountId,
+      filter: data.filter
+    },
+    query: {
+      query: data.query,
+      pageIndex: data.pageIndex,
+      pageSize: data.pageSize
+    },
+    errors: {
+      403: "You do not have access to the specified sub account"
+    }
+  });
+};
+var grantWindow = () => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/supportAccess/window",
+    errors: {
+      400: "Maximum limit on access duration exceeded"
+    }
+  });
+};
+var getWindow = () => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/supportAccess/window",
+    errors: {
+      404: "No access provided for the requester or the access is expired"
+    }
+  });
+};
+var extendWindow = () => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/supportAccess/window",
+    errors: {
+      404: "No access provided for the requester"
+    }
+  });
+};
+var revokeWindow = () => {
+  return request(OpenAPI, {
+    method: "DELETE",
+    url: "/api/v1/supportAccess/window"
+  });
+};
+var getExtractionResults = (data) => {
+  return request(OpenAPI, {
+    method: "GET",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/getResults",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      404: "Extraction has not started for this negotiation"
+    }
+  });
+};
+var scheduleExtraction = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/start",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Extraction is not enabled for the document type or the negotiation is not offline"
+    }
+  });
+};
+var updateSelectedElections = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/elections",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var updateExtractionFeedback = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/feedback",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var updateUserAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/answers",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var resetUserAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/resetAnswers",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    body: data.requestBody,
+    mediaType: "application/json",
+    errors: {
+      404: "Negotiation or election not found"
+    }
+  });
+};
+var cancelExtraction = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/cancel",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Extraction has not started for the negotiation or has already been accepted"
+    }
+  });
+};
+var applyExtractedAnswers = (data) => {
+  return request(OpenAPI, {
+    method: "PUT",
+    url: "/api/v1/subAccounts/{subAccountId}/negotiations/{negotiationId}/extraction/apply",
+    path: {
+      subAccountId: data.subAccountId,
+      negotiationId: data.negotiationId
+    },
+    errors: {
+      403: "Extraction has not started for the negotiation or has already been accepted"
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  CancelError,
+  CancelablePromise,
+  OpenAPI,
+  acceptAllCounterpartyPositions,
+  acceptAllCustodianTemplatePositions,
+  acceptAllPositionsFromFork,
+  acceptAllPositionsFromPreviousVersion,
+  acceptAllPresetPositions,
+  acceptCounterpartyPosition,
+  acceptNestedAnswersCounterpartyPosition,
+  accountSummary,
+  addApprovalComment,
+  addComment,
+  addElectionApproval,
+  addElectionRejection,
+  addWatchers,
+  applyExtractedAnswers,
+  approveFinalDocument,
+  assignEntity,
+  assignToMe,
+  assignUser,
+  auditTrailFilters,
+  auditTrailForAccountAsExcel,
+  auditTrailForAccountAsJson,
+  auditTrailForSubAccountAsExcel,
+  auditTrailForSubAccountAsJson,
+  authPing,
+  breakingChanges,
+  bulkSetsJobCount,
+  cancel,
+  cancelExtraction,
+  cancelNegotiations,
+  cancelNegotiationsJobCount,
+  changeSigningMode,
+  checkAuxiliaryDocument,
+  checkOfflineNegotiatedDocument,
+  checkSignedExecutedVersion,
+  checkSignedSignaturePagePdf,
+  clonePreset,
+  confirm,
+  confirmExecutionVersion,
+  consentCodeCallback,
+  createAuditTrailJson,
+  createAuditTrailPdf,
+  createAuditTrailXlsx,
+  createBulkSet,
+  createGroup,
+  createNegotiation,
+  createPreset,
+  createPresetAuditTrailJson,
+  createPresetAuditTrailXlsx,
+  createSignaturePagePdf,
+  createSigningPack,
+  deleteApprovalComment,
+  deleteAuxiliaryDocument,
+  deleteBulkSetAttachment,
+  deleteComment,
+  deleteCoverNote,
+  deleteDocumentDraftingNote,
+  deleteDocumentElectionDraftingNote,
+  deleteDraftingNotesDocument,
+  deleteEntity,
+  deleteExecutionAttachment,
+  deleteExternalAttachment,
+  deleteGeneralCoverNote,
+  deleteOfflineNegotiatedDocument,
+  deletePreset,
+  deleteSignedExecutedVersion,
+  deleteSignedSignaturePageForParty,
+  documentRenderTemplate,
+  documentsFilter,
+  downloadActiveNegotiationsReportAsExcel,
+  downloadDashboardReportAsExcel,
+  downloadExecutedNegotiationsAsExcel,
+  downloadNegotiation,
+  downloadPostExecutionPack,
+  downloadPreExecutionCounterpartyNegotiation,
+  downloadPreset,
+  editAnswers,
+  editApprovalComment,
+  editDefaultAnswers,
+  emailPreferences,
+  extendWindow,
+  forkNegotiation,
+  generateAndMaybeSendEnvelope,
+  getAccessibleNegotiation,
+  getAccountRelationshipSummaries,
+  getAllNegotiationCommentsForSubAccount,
+  getAllVersions,
+  getAmendDefaults,
+  getAnnotatedOfflineNegotiatedDocument,
+  getApprovalComments,
+  getApprovalHistory,
+  getApprovalRound,
+  getAsCdm,
+  getAuxiliaryDocument,
+  getBulkSet,
+  getBulkSetAttachment,
+  getChannelTimeline,
+  getCommentSummary,
+  getComments,
+  getCompanyByEntityId,
+  getDocument,
+  getDocumentSchema,
+  getDownloadActiveNegotiationsReportAsExcel,
+  getDownloadExecutedNegotiationsAsExcel,
+  getDraftingNotes,
+  getDraftingNotesDocument,
+  getElectionAnswer,
+  getExecutedNegotiationSummary,
+  getExecutionAttachment,
+  getExternalAttachment,
+  getExtractionResults,
+  getGroupNames,
+  getLatestDocumentSchema,
+  getLegacyStatistics,
+  getMajorVersions,
+  getMultipleNestedAnswers,
+  getNegotiation,
+  getNegotiationDeltas,
+  getNegotiationDraftingNotes,
+  getNegotiationESignStatus,
+  getNegotiationFilesSummary,
+  getNegotiationsGroup,
+  getNestedAnswers,
+  getOfflineNegotiatedDocument,
+  getOfflineNegotiatedDocumentAnnotations,
+  getOriginalAnswersForForkNegotiation,
+  getOtherPartyAnswers,
+  getPartyAnswers,
+  getPreset,
+  getPreviousActiveUsers,
+  getPreviousMajorVersionsNestedAnswerElections,
+  getPreviousMajorVersionsNestedAnswerIds,
+  getProfile,
+  getSecurityContext,
+  getSettings,
+  getSignedExecutedVersion,
+  getSignedSignaturePagePdf,
+  getSsoConfig,
+  getStatistics,
+  getStatisticsOverview,
+  getSubAccount,
+  getTimeline,
+  getTimelineActivity,
+  getUserStatistics,
+  getUsers,
+  getUsersForPicker,
+  getWatchers,
+  getWindow,
+  grantAllNegotiationsAccess,
+  grantNegotiationsAccess,
+  grantPresetsAccess,
+  grantWindow,
+  initialAnswers,
+  listAdvisorsForWorkspace,
+  listAllPresetsForSubAccountV1,
+  listAllPresetsForSubAccountV2,
+  listBulkSets,
+  listDocuments,
+  listDocumentsVersionsSummary,
+  listDocumentsWithPagination,
+  listEntities,
+  listExecutionAttachments,
+  listExternalAttachments,
+  listNegotiations,
+  listPotentialNegotiationAdvisors,
+  listPotentialPresetAdvisors,
+  listPresets,
+  listSubAccounts,
+  markActivityEventsAsViewed,
+  markApprovalCommentsAsViewed,
+  markAsFinal,
+  markAsOffline,
+  markCommentEventsAsViewed,
+  markEventsAsViewed,
+  moveEntity,
+  negotiationForkHistory,
+  negotiationGetDocumentSchema,
+  negotiationRenderTemplate,
+  negotiationSendForApproval,
+  negotiationsFilter,
+  notifyOfDraft,
+  obtainConsent,
+  overrideApproveFinalDocument,
+  overrideElectionApproval,
+  overrideElectionRejection,
+  overrideRejectFinalDocument,
+  patchEmailPreferences,
+  presetEditAnswers,
+  presetGetDocumentSchema,
+  presetGetMultipleNestedAnswers,
+  presetGetNestedAnswers,
+  presetRenderTemplate,
+  presetSendForApproval,
+  presetSetElectionApproval,
+  presetSetFinalApproval,
+  presetSetMultipleNestedAnswers,
+  presetSetNestedAnswers,
+  presetSwapParties,
+  queueGenerateNegotiationDocumentJob,
+  rejectFinalDocument,
+  removeWatchers,
+  renameExecutionAttachment,
+  resetUserAnswers,
+  retract,
+  revertToAmending,
+  revokeNegotiationsAccess,
+  revokePresetsAccess,
+  revokeWindow,
+  scheduleExtraction,
+  schemaAvailableAsCdm,
+  searchEntity,
+  sendBulkSetToCounterpartiesInitial,
+  sendChaserEmail,
+  sendDocumentApprovalReminder,
+  sendElectionApprovalReminder,
+  sendGroupToCounterparty,
+  sendToCounterparty,
+  sendToCounterpartyInitial,
+  setAuxiliaryDocument,
+  setBulkSetAttachments,
+  setCounterparties,
+  setElectionApproval,
+  setExecutionAttachment,
+  setExecutionAttachments,
+  setExternalAttachment,
+  setExternalAttachments,
+  setFinalApproval,
+  setGeneralCoverNote,
+  setMultipleNestedAnswers,
+  setNestedAnswers,
+  setOfflineNegotiatedDocument,
+  setOwnerEntity,
+  setPreset,
+  setReceiverEntity,
+  setSignedExecutedVersion,
+  setSignedSignaturePageForParty,
+  suggestGroupName,
+  swapParties,
+  unsubscribe,
+  updateAttachDocx,
+  updateComment,
+  updateCoverNote,
+  updateCustomFields,
+  updateDocumentDraftingNote,
+  updateDocumentElectionDraftingNote,
+  updateDraftingNotes,
+  updateExtractionFeedback,
+  updateGroupMembers,
+  updateGroupName,
+  updateMetadata,
+  updateNegotiationsToMatch,
+  updateSelectedElections,
+  updateSubAccount,
+  updateUserAnswers,
+  upgradePresetSchema,
+  upgradeSchema,
+  usersWithNegotiationAccess,
+  validateDraftReceiverEmails,
+  validateEntities,
+  version,
+  voidESignEnvelopeForNegotiation
+});
+//# sourceMappingURL=index.cjs.map