@layerzerolabs/common-canton 1.2.69 → 1.2.71

package/dist/GJFARMTH.js

@@ -0,0 +1,2716 @@
+import { UpdateUserResponseFromJSON } from './YG6MDQAI.js';
+import { UpdateVettedPackagesRequestToJSON } from './HU7X7G5L.js';
+import { UpdateVettedPackagesResponseFromJSON } from './76PPVRJ6.js';
+import { UpdatePartyDetailsRequestToJSON } from './F6OBDGNC.js';
+import { UpdatePartyDetailsResponseFromJSON } from './Q3CWBD5A.js';
+import { UpdateUserIdentityProviderIdRequestToJSON } from './DUQWP47Z.js';
+import { UpdateUserRequestToJSON } from './3YMFQHQ2.js';
+import { UpdateIdentityProviderConfigRequestToJSON } from './6K3YSZCK.js';
+import { UpdateIdentityProviderConfigResponseFromJSON } from './Y7ND62EN.js';
+import { SubmitAndWaitResponseFromJSON } from './FB6G6OD4.js';
+import { SubmitReassignmentRequestToJSON } from './PGQCNYFD.js';
+import { SubmitAndWaitForReassignmentRequestToJSON } from './7PHM6HLD.js';
+import { RevokeUserRightsRequestToJSON } from './U64PVM2G.js';
+import { RevokeUserRightsResponseFromJSON } from './66C2UKUB.js';
+import { ListIdentityProviderConfigsResponseFromJSON } from './QKX6RB6N.js';
+import { ListKnownPartiesResponseFromJSON } from './5PL2GRP6.js';
+import { ListPackagesResponseFromJSON } from './DNH3CRBL.js';
+import { ListUserRightsResponseFromJSON } from './GN3EMRUZ.js';
+import { ListUsersResponseFromJSON } from './KKCWYT6E.js';
+import { ListVettedPackagesRequestToJSON } from './S7OPYTA6.js';
+import { ListVettedPackagesResponseFromJSON } from './NOXVUNXQ.js';
+import { JsSubmitAndWaitForTransactionRequestToJSON } from './74GXIV45.js';
+import { JsSubmitAndWaitForTransactionResponseFromJSON } from './CJNH6ICZ.js';
+import { JsSubmitAndWaitForTransactionTreeResponseFromJSON } from './LYW3PRU5.js';
+import { JsPrepareSubmissionRequestToJSON } from './AAYMVMGA.js';
+import { JsPrepareSubmissionResponseFromJSON } from './53STMMNU.js';
+import { JsSubmitAndWaitForReassignmentResponseFromJSON } from './3T46OKQU.js';
+import { JsGetTransactionResponseFromJSON } from './VDBQAUSY.js';
+import { JsGetTransactionTreeResponseFromJSON } from './6GU7J47E.js';
+import { JsGetUpdateResponseFromJSON } from './QYKMFCVF.js';
+import { JsGetUpdateTreesResponseFromJSON } from './AE56UC5I.js';
+import { JsGetUpdatesResponseFromJSON } from './FYF3KCTO.js';
+import { JsExecuteSubmissionAndWaitForTransactionRequestToJSON } from './C4O6KF4R.js';
+import { JsExecuteSubmissionAndWaitForTransactionResponseFromJSON } from './PW7NJ3JL.js';
+import { JsExecuteSubmissionAndWaitRequestToJSON } from './QZKEWDGH.js';
+import { JsExecuteSubmissionRequestToJSON } from './A7VF3ZJF.js';
+import { JsGetActiveContractsResponseFromJSON } from './KA2OXQFA.js';
+import { JsGetEventsByContractIdResponseFromJSON } from './MXJ2SKCA.js';
+import { JsCommandsToJSON } from './TV3E6NFT.js';
+import { GetUpdatesRequestToJSON } from './WEOR7EMZ.js';
+import { GetUserResponseFromJSON } from './WLJJ4FDL.js';
+import { GrantUserRightsRequestToJSON } from './OUSDBPTI.js';
+import { GrantUserRightsResponseFromJSON } from './FA5HJRNC.js';
+import { GetPartiesResponseFromJSON } from './GJPYFCRF.js';
+import { GetPreferredPackageVersionResponseFromJSON } from './LEDX6CMV.js';
+import { GetPreferredPackagesRequestToJSON } from './G4FJL7ZV.js';
+import { GetPreferredPackagesResponseFromJSON } from './D5KKWJ4T.js';
+import { GetTransactionByIdRequestToJSON } from './U7QJUV2C.js';
+import { GetTransactionByOffsetRequestToJSON } from './NRS4DZPT.js';
+import { GetUpdateByIdRequestToJSON } from './IQJ5FFO2.js';
+import { GetUpdateByOffsetRequestToJSON } from './UNTLGCGB.js';
+import { GetConnectedSynchronizersResponseFromJSON } from './SF7H2DPL.js';
+import { GetEventsByContractIdRequestToJSON } from './BZPOVFBV.js';
+import { GetIdentityProviderConfigResponseFromJSON } from './OMKZNVQ6.js';
+import { GetLatestPrunedOffsetsResponseFromJSON } from './PBBQTZR5.js';
+import { GetLedgerApiVersionResponseFromJSON } from './HPOEKKSQ.js';
+import { GetLedgerEndResponseFromJSON } from './KOUK7GBL.js';
+import { GetPackageStatusResponseFromJSON } from './HZG6J4V4.js';
+import { GetParticipantIdResponseFromJSON } from './RY2LC7P3.js';
+import { GenerateExternalPartyTopologyRequestToJSON } from './I2M5WSEM.js';
+import { GenerateExternalPartyTopologyResponseFromJSON } from './BXDXCO3L.js';
+import { GetActiveContractsRequestToJSON } from './ACTUREBJ.js';
+import { ExecuteSubmissionAndWaitResponseFromJSON } from './4XJYWTSD.js';
+import { CreateIdentityProviderConfigRequestToJSON } from './JNFIJ7LA.js';
+import { CreateIdentityProviderConfigResponseFromJSON } from './YJ63OODS.js';
+import { CreateUserRequestToJSON } from './WLN7SJMS.js';
+import { CreateUserResponseFromJSON } from './ZDVQJMLH.js';
+import { CompletionStreamRequestToJSON } from './JVRWQ36T.js';
+import { CompletionStreamResponseFromJSON } from './NVM727ES.js';
+import { AllocateExternalPartyRequestToJSON } from './TVDUWBAO.js';
+import { AllocateExternalPartyResponseFromJSON } from './3PWAEVJM.js';
+import { AllocatePartyRequestToJSON } from './FBGPMEXZ.js';
+import { AllocatePartyResponseFromJSON } from './AJ4M7JFK.js';
+import { BaseAPI, RequiredError, JSONApiResponse, BlobApiResponse, VoidApiResponse } from './KBNUN3MF.js';
+import { __name } from './VUOMXK5T.js';
+
+// src/open-api/apis/DefaultApi.ts
+var DefaultApi = class extends BaseAPI {
+  static {
+    __name(this, "DefaultApi");
+  }
+  /**
+   * Creates request options for deleteV2IdpsIdpId without sending the request
+   */
+  async deleteV2IdpsIdpIdRequestOpts(requestParameters) {
+    if (requestParameters["idpId"] == null) {
+      throw new RequiredError("idpId", 'Required parameter "idpId" was null or undefined when calling deleteV2IdpsIdpId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/idps/{idp-id}`;
+    urlPath = urlPath.replace(`{${"idp-id"}}`, encodeURIComponent(String(requestParameters["idpId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Delete identity provider config
+   */
+  async deleteV2IdpsIdpIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteV2IdpsIdpIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Delete identity provider config
+   */
+  async deleteV2IdpsIdpId(requestParameters, initOverrides) {
+    const response = await this.deleteV2IdpsIdpIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for deleteV2UsersUserId without sending the request
+   */
+  async deleteV2UsersUserIdRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling deleteV2UsersUserId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Delete user.
+   */
+  async deleteV2UsersUserIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteV2UsersUserIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Delete user.
+   */
+  async deleteV2UsersUserId(requestParameters, initOverrides) {
+    const response = await this.deleteV2UsersUserIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2AuthenticatedUser without sending the request
+   */
+  async getV2AuthenticatedUserRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["identityProviderId"] != null) {
+      queryParameters["identity-provider-id"] = requestParameters["identityProviderId"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/authenticated-user`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get current user details (uses user for JWT).
+   */
+  async getV2AuthenticatedUserRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2AuthenticatedUserRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetUserResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get current user details (uses user for JWT).
+   */
+  async getV2AuthenticatedUser(requestParameters = {}, initOverrides) {
+    const response = await this.getV2AuthenticatedUserRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2Idps without sending the request
+   */
+  async getV2IdpsRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/idps`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List all identity provider configs
+   */
+  async getV2IdpsRaw(initOverrides) {
+    const requestOptions = await this.getV2IdpsRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListIdentityProviderConfigsResponseFromJSON(jsonValue));
+  }
+  /**
+   * List all identity provider configs
+   */
+  async getV2Idps(initOverrides) {
+    const response = await this.getV2IdpsRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2IdpsIdpId without sending the request
+   */
+  async getV2IdpsIdpIdRequestOpts(requestParameters) {
+    if (requestParameters["idpId"] == null) {
+      throw new RequiredError("idpId", 'Required parameter "idpId" was null or undefined when calling getV2IdpsIdpId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/idps/{idp-id}`;
+    urlPath = urlPath.replace(`{${"idp-id"}}`, encodeURIComponent(String(requestParameters["idpId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get identity provider config
+   */
+  async getV2IdpsIdpIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2IdpsIdpIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetIdentityProviderConfigResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get identity provider config
+   */
+  async getV2IdpsIdpId(requestParameters, initOverrides) {
+    const response = await this.getV2IdpsIdpIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2InteractiveSubmissionPreferredPackageVersion without sending the request
+   */
+  async getV2InteractiveSubmissionPreferredPackageVersionRequestOpts(requestParameters) {
+    if (requestParameters["packageName"] == null) {
+      throw new RequiredError("packageName", 'Required parameter "packageName" was null or undefined when calling getV2InteractiveSubmissionPreferredPackageVersion().');
+    }
+    const queryParameters = {};
+    if (requestParameters["parties"] != null) {
+      queryParameters["parties"] = requestParameters["parties"];
+    }
+    if (requestParameters["packageName"] != null) {
+      queryParameters["package-name"] = requestParameters["packageName"];
+    }
+    if (requestParameters["vettingValidAt"] != null) {
+      queryParameters["vetting_valid_at"] = requestParameters["vettingValidAt"].toISOString();
+    }
+    if (requestParameters["synchronizerId"] != null) {
+      queryParameters["synchronizer-id"] = requestParameters["synchronizerId"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/interactive-submission/preferred-package-version`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get the preferred package version for constructing a command submission
+   */
+  async getV2InteractiveSubmissionPreferredPackageVersionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2InteractiveSubmissionPreferredPackageVersionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetPreferredPackageVersionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get the preferred package version for constructing a command submission
+   */
+  async getV2InteractiveSubmissionPreferredPackageVersion(requestParameters, initOverrides) {
+    const response = await this.getV2InteractiveSubmissionPreferredPackageVersionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2PackageVetting without sending the request
+   */
+  async getV2PackageVettingRequestOpts(requestParameters) {
+    if (requestParameters["listVettedPackagesRequest"] == null) {
+      throw new RequiredError("listVettedPackagesRequest", 'Required parameter "listVettedPackagesRequest" was null or undefined when calling getV2PackageVetting().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/package-vetting`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters,
+      body: ListVettedPackagesRequestToJSON(requestParameters["listVettedPackagesRequest"])
+    };
+  }
+  /**
+   * List vetted packages
+   */
+  async getV2PackageVettingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PackageVettingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListVettedPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * List vetted packages
+   */
+  async getV2PackageVetting(requestParameters, initOverrides) {
+    const response = await this.getV2PackageVettingRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2Packages without sending the request
+   */
+  async getV2PackagesRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/packages`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List all packages uploaded on the participant node
+   */
+  async getV2PackagesRaw(initOverrides) {
+    const requestOptions = await this.getV2PackagesRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * List all packages uploaded on the participant node
+   */
+  async getV2Packages(initOverrides) {
+    const response = await this.getV2PackagesRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2PackagesPackageId without sending the request
+   */
+  async getV2PackagesPackageIdRequestOpts(requestParameters) {
+    if (requestParameters["packageId"] == null) {
+      throw new RequiredError("packageId", 'Required parameter "packageId" was null or undefined when calling getV2PackagesPackageId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/packages/{package-id}`;
+    urlPath = urlPath.replace(`{${"package-id"}}`, encodeURIComponent(String(requestParameters["packageId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Download the package for the requested package-id
+   */
+  async getV2PackagesPackageIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PackagesPackageIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new BlobApiResponse(response);
+  }
+  /**
+   * Download the package for the requested package-id
+   */
+  async getV2PackagesPackageId(requestParameters, initOverrides) {
+    const response = await this.getV2PackagesPackageIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2PackagesPackageIdStatus without sending the request
+   */
+  async getV2PackagesPackageIdStatusRequestOpts(requestParameters) {
+    if (requestParameters["packageId"] == null) {
+      throw new RequiredError("packageId", 'Required parameter "packageId" was null or undefined when calling getV2PackagesPackageIdStatus().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/packages/{package-id}/status`;
+    urlPath = urlPath.replace(`{${"package-id"}}`, encodeURIComponent(String(requestParameters["packageId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get package status
+   */
+  async getV2PackagesPackageIdStatusRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PackagesPackageIdStatusRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetPackageStatusResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get package status
+   */
+  async getV2PackagesPackageIdStatus(requestParameters, initOverrides) {
+    const response = await this.getV2PackagesPackageIdStatusRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2Parties without sending the request
+   */
+  async getV2PartiesRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["pageSize"] != null) {
+      queryParameters["pageSize"] = requestParameters["pageSize"];
+    }
+    if (requestParameters["pageToken"] != null) {
+      queryParameters["pageToken"] = requestParameters["pageToken"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List all known parties.
+   */
+  async getV2PartiesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PartiesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListKnownPartiesResponseFromJSON(jsonValue));
+  }
+  /**
+   * List all known parties.
+   */
+  async getV2Parties(requestParameters = {}, initOverrides) {
+    const response = await this.getV2PartiesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2PartiesParticipantId without sending the request
+   */
+  async getV2PartiesParticipantIdRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties/participant-id`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get participant id
+   */
+  async getV2PartiesParticipantIdRaw(initOverrides) {
+    const requestOptions = await this.getV2PartiesParticipantIdRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetParticipantIdResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get participant id
+   */
+  async getV2PartiesParticipantId(initOverrides) {
+    const response = await this.getV2PartiesParticipantIdRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2PartiesParty without sending the request
+   */
+  async getV2PartiesPartyRequestOpts(requestParameters) {
+    if (requestParameters["party"] == null) {
+      throw new RequiredError("party", 'Required parameter "party" was null or undefined when calling getV2PartiesParty().');
+    }
+    const queryParameters = {};
+    if (requestParameters["identityProviderId"] != null) {
+      queryParameters["identity-provider-id"] = requestParameters["identityProviderId"];
+    }
+    if (requestParameters["parties"] != null) {
+      queryParameters["parties"] = requestParameters["parties"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties/{party}`;
+    urlPath = urlPath.replace(`{${"party"}}`, encodeURIComponent(String(requestParameters["party"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get party details
+   */
+  async getV2PartiesPartyRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PartiesPartyRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetPartiesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get party details
+   */
+  async getV2PartiesParty(requestParameters, initOverrides) {
+    const response = await this.getV2PartiesPartyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2StateConnectedSynchronizers without sending the request
+   */
+  async getV2StateConnectedSynchronizersRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["party"] != null) {
+      queryParameters["party"] = requestParameters["party"];
+    }
+    if (requestParameters["participantId"] != null) {
+      queryParameters["participantId"] = requestParameters["participantId"];
+    }
+    if (requestParameters["identityProviderId"] != null) {
+      queryParameters["identityProviderId"] = requestParameters["identityProviderId"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/state/connected-synchronizers`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get connected synchronizers
+   */
+  async getV2StateConnectedSynchronizersRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2StateConnectedSynchronizersRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetConnectedSynchronizersResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get connected synchronizers
+   */
+  async getV2StateConnectedSynchronizers(requestParameters = {}, initOverrides) {
+    const response = await this.getV2StateConnectedSynchronizersRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2StateLatestPrunedOffsets without sending the request
+   */
+  async getV2StateLatestPrunedOffsetsRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/state/latest-pruned-offsets`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get latest pruned offsets
+   */
+  async getV2StateLatestPrunedOffsetsRaw(initOverrides) {
+    const requestOptions = await this.getV2StateLatestPrunedOffsetsRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetLatestPrunedOffsetsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get latest pruned offsets
+   */
+  async getV2StateLatestPrunedOffsets(initOverrides) {
+    const response = await this.getV2StateLatestPrunedOffsetsRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2StateLedgerEnd without sending the request
+   */
+  async getV2StateLedgerEndRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/state/ledger-end`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get ledger end
+   */
+  async getV2StateLedgerEndRaw(initOverrides) {
+    const requestOptions = await this.getV2StateLedgerEndRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetLedgerEndResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get ledger end
+   */
+  async getV2StateLedgerEnd(initOverrides) {
+    const response = await this.getV2StateLedgerEndRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2UpdatesTransactionTreeByIdUpdateId without sending the request
+   * @deprecated
+   */
+  async getV2UpdatesTransactionTreeByIdUpdateIdRequestOpts(requestParameters) {
+    if (requestParameters["updateId"] == null) {
+      throw new RequiredError("updateId", 'Required parameter "updateId" was null or undefined when calling getV2UpdatesTransactionTreeByIdUpdateId().');
+    }
+    const queryParameters = {};
+    if (requestParameters["parties"] != null) {
+      queryParameters["parties"] = requestParameters["parties"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/transaction-tree-by-id/{update-id}`;
+    urlPath = urlPath.replace(`{${"update-id"}}`, encodeURIComponent(String(requestParameters["updateId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get transaction tree by id. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-id instead.
+   * @deprecated
+   */
+  async getV2UpdatesTransactionTreeByIdUpdateIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2UpdatesTransactionTreeByIdUpdateIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetTransactionTreeResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get transaction tree by id. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-id instead.
+   * @deprecated
+   */
+  async getV2UpdatesTransactionTreeByIdUpdateId(requestParameters, initOverrides) {
+    const response = await this.getV2UpdatesTransactionTreeByIdUpdateIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2UpdatesTransactionTreeByOffsetOffset without sending the request
+   * @deprecated
+   */
+  async getV2UpdatesTransactionTreeByOffsetOffsetRequestOpts(requestParameters) {
+    if (requestParameters["offset"] == null) {
+      throw new RequiredError("offset", 'Required parameter "offset" was null or undefined when calling getV2UpdatesTransactionTreeByOffsetOffset().');
+    }
+    const queryParameters = {};
+    if (requestParameters["parties"] != null) {
+      queryParameters["parties"] = requestParameters["parties"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/transaction-tree-by-offset/{offset}`;
+    urlPath = urlPath.replace(`{${"offset"}}`, encodeURIComponent(String(requestParameters["offset"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get transaction tree by offset. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-offset instead.
+   * @deprecated
+   */
+  async getV2UpdatesTransactionTreeByOffsetOffsetRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2UpdatesTransactionTreeByOffsetOffsetRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetTransactionTreeResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get transaction tree by offset. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-offset instead.
+   * @deprecated
+   */
+  async getV2UpdatesTransactionTreeByOffsetOffset(requestParameters, initOverrides) {
+    const response = await this.getV2UpdatesTransactionTreeByOffsetOffsetRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2Users without sending the request
+   */
+  async getV2UsersRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["pageSize"] != null) {
+      queryParameters["pageSize"] = requestParameters["pageSize"];
+    }
+    if (requestParameters["pageToken"] != null) {
+      queryParameters["pageToken"] = requestParameters["pageToken"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List all users.
+   */
+  async getV2UsersRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2UsersRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListUsersResponseFromJSON(jsonValue));
+  }
+  /**
+   * List all users.
+   */
+  async getV2Users(requestParameters = {}, initOverrides) {
+    const response = await this.getV2UsersRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2UsersUserId without sending the request
+   */
+  async getV2UsersUserIdRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling getV2UsersUserId().');
+    }
+    const queryParameters = {};
+    if (requestParameters["identityProviderId"] != null) {
+      queryParameters["identity-provider-id"] = requestParameters["identityProviderId"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get user details.
+   */
+  async getV2UsersUserIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2UsersUserIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetUserResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get user details.
+   */
+  async getV2UsersUserId(requestParameters, initOverrides) {
+    const response = await this.getV2UsersUserIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2UsersUserIdRights without sending the request
+   */
+  async getV2UsersUserIdRightsRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling getV2UsersUserIdRights().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}/rights`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List user rights.
+   */
+  async getV2UsersUserIdRightsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2UsersUserIdRightsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListUserRightsResponseFromJSON(jsonValue));
+  }
+  /**
+   * List user rights.
+   */
+  async getV2UsersUserIdRights(requestParameters, initOverrides) {
+    const response = await this.getV2UsersUserIdRightsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2Version without sending the request
+   */
+  async getV2VersionRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/version`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get the version details of the participant node
+   */
+  async getV2VersionRaw(initOverrides) {
+    const requestOptions = await this.getV2VersionRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetLedgerApiVersionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get the version details of the participant node
+   */
+  async getV2Version(initOverrides) {
+    const response = await this.getV2VersionRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for patchV2IdpsIdpId without sending the request
+   */
+  async patchV2IdpsIdpIdRequestOpts(requestParameters) {
+    if (requestParameters["idpId"] == null) {
+      throw new RequiredError("idpId", 'Required parameter "idpId" was null or undefined when calling patchV2IdpsIdpId().');
+    }
+    if (requestParameters["updateIdentityProviderConfigRequest"] == null) {
+      throw new RequiredError("updateIdentityProviderConfigRequest", 'Required parameter "updateIdentityProviderConfigRequest" was null or undefined when calling patchV2IdpsIdpId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/idps/{idp-id}`;
+    urlPath = urlPath.replace(`{${"idp-id"}}`, encodeURIComponent(String(requestParameters["idpId"])));
+    return {
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateIdentityProviderConfigRequestToJSON(requestParameters["updateIdentityProviderConfigRequest"])
+    };
+  }
+  /**
+   * Update identity provider config
+   */
+  async patchV2IdpsIdpIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2IdpsIdpIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdateIdentityProviderConfigResponseFromJSON(jsonValue));
+  }
+  /**
+   * Update identity provider config
+   */
+  async patchV2IdpsIdpId(requestParameters, initOverrides) {
+    const response = await this.patchV2IdpsIdpIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for patchV2PartiesParty without sending the request
+   */
+  async patchV2PartiesPartyRequestOpts(requestParameters) {
+    if (requestParameters["party"] == null) {
+      throw new RequiredError("party", 'Required parameter "party" was null or undefined when calling patchV2PartiesParty().');
+    }
+    if (requestParameters["updatePartyDetailsRequest"] == null) {
+      throw new RequiredError("updatePartyDetailsRequest", 'Required parameter "updatePartyDetailsRequest" was null or undefined when calling patchV2PartiesParty().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties/{party}`;
+    urlPath = urlPath.replace(`{${"party"}}`, encodeURIComponent(String(requestParameters["party"])));
+    return {
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdatePartyDetailsRequestToJSON(requestParameters["updatePartyDetailsRequest"])
+    };
+  }
+  /**
+   * Allocate a new party to the participant node
+   */
+  async patchV2PartiesPartyRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2PartiesPartyRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdatePartyDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Allocate a new party to the participant node
+   */
+  async patchV2PartiesParty(requestParameters, initOverrides) {
+    const response = await this.patchV2PartiesPartyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for patchV2UsersUserId without sending the request
+   */
+  async patchV2UsersUserIdRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling patchV2UsersUserId().');
+    }
+    if (requestParameters["updateUserRequest"] == null) {
+      throw new RequiredError("updateUserRequest", 'Required parameter "updateUserRequest" was null or undefined when calling patchV2UsersUserId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateUserRequestToJSON(requestParameters["updateUserRequest"])
+    };
+  }
+  /**
+   * Update  user.
+   */
+  async patchV2UsersUserIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2UsersUserIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdateUserResponseFromJSON(jsonValue));
+  }
+  /**
+   * Update  user.
+   */
+  async patchV2UsersUserId(requestParameters, initOverrides) {
+    const response = await this.patchV2UsersUserIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for patchV2UsersUserIdIdentityProviderId without sending the request
+   */
+  async patchV2UsersUserIdIdentityProviderIdRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling patchV2UsersUserIdIdentityProviderId().');
+    }
+    if (requestParameters["updateUserIdentityProviderIdRequest"] == null) {
+      throw new RequiredError("updateUserIdentityProviderIdRequest", 'Required parameter "updateUserIdentityProviderIdRequest" was null or undefined when calling patchV2UsersUserIdIdentityProviderId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}/identity-provider-id`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateUserIdentityProviderIdRequestToJSON(requestParameters["updateUserIdentityProviderIdRequest"])
+    };
+  }
+  /**
+   * Update user identity provider.
+   */
+  async patchV2UsersUserIdIdentityProviderIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2UsersUserIdIdentityProviderIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update user identity provider.
+   */
+  async patchV2UsersUserIdIdentityProviderId(requestParameters, initOverrides) {
+    const response = await this.patchV2UsersUserIdIdentityProviderIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for patchV2UsersUserIdRights without sending the request
+   */
+  async patchV2UsersUserIdRightsRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling patchV2UsersUserIdRights().');
+    }
+    if (requestParameters["revokeUserRightsRequest"] == null) {
+      throw new RequiredError("revokeUserRightsRequest", 'Required parameter "revokeUserRightsRequest" was null or undefined when calling patchV2UsersUserIdRights().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}/rights`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "PATCH",
+      headers: headerParameters,
+      query: queryParameters,
+      body: RevokeUserRightsRequestToJSON(requestParameters["revokeUserRightsRequest"])
+    };
+  }
+  /**
+   * Revoke user rights.
+   */
+  async patchV2UsersUserIdRightsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2UsersUserIdRightsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RevokeUserRightsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Revoke user rights.
+   */
+  async patchV2UsersUserIdRights(requestParameters, initOverrides) {
+    const response = await this.patchV2UsersUserIdRightsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsAsyncSubmit without sending the request
+   */
+  async postV2CommandsAsyncSubmitRequestOpts(requestParameters) {
+    if (requestParameters["jsCommands"] == null) {
+      throw new RequiredError("jsCommands", 'Required parameter "jsCommands" was null or undefined when calling postV2CommandsAsyncSubmit().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/async/submit`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsCommandsToJSON(requestParameters["jsCommands"])
+    };
+  }
+  /**
+   * Submit a command asynchronously
+   */
+  async postV2CommandsAsyncSubmitRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsAsyncSubmitRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Submit a command asynchronously
+   */
+  async postV2CommandsAsyncSubmit(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsAsyncSubmitRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsAsyncSubmitReassignment without sending the request
+   */
+  async postV2CommandsAsyncSubmitReassignmentRequestOpts(requestParameters) {
+    if (requestParameters["submitReassignmentRequest"] == null) {
+      throw new RequiredError("submitReassignmentRequest", 'Required parameter "submitReassignmentRequest" was null or undefined when calling postV2CommandsAsyncSubmitReassignment().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/async/submit-reassignment`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: SubmitReassignmentRequestToJSON(requestParameters["submitReassignmentRequest"])
+    };
+  }
+  /**
+   * Submit reassignment command asynchronously
+   */
+  async postV2CommandsAsyncSubmitReassignmentRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsAsyncSubmitReassignmentRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Submit reassignment command asynchronously
+   */
+  async postV2CommandsAsyncSubmitReassignment(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsAsyncSubmitReassignmentRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsCompletions without sending the request
+   */
+  async postV2CommandsCompletionsRequestOpts(requestParameters) {
+    if (requestParameters["completionStreamRequest"] == null) {
+      throw new RequiredError("completionStreamRequest", 'Required parameter "completionStreamRequest" was null or undefined when calling postV2CommandsCompletions().');
+    }
+    const queryParameters = {};
+    if (requestParameters["limit"] != null) {
+      queryParameters["limit"] = requestParameters["limit"];
+    }
+    if (requestParameters["streamIdleTimeoutMs"] != null) {
+      queryParameters["stream_idle_timeout_ms"] = requestParameters["streamIdleTimeoutMs"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/completions`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CompletionStreamRequestToJSON(requestParameters["completionStreamRequest"])
+    };
+  }
+  /**
+   * Query completions list (blocking call) Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   */
+  async postV2CommandsCompletionsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsCompletionsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(CompletionStreamResponseFromJSON));
+  }
+  /**
+   * Query completions list (blocking call) Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   */
+  async postV2CommandsCompletions(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsCompletionsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsSubmitAndWait without sending the request
+   */
+  async postV2CommandsSubmitAndWaitRequestOpts(requestParameters) {
+    if (requestParameters["jsCommands"] == null) {
+      throw new RequiredError("jsCommands", 'Required parameter "jsCommands" was null or undefined when calling postV2CommandsSubmitAndWait().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/submit-and-wait`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsCommandsToJSON(requestParameters["jsCommands"])
+    };
+  }
+  /**
+   * Submit a batch of commands and wait for the completion details
+   */
+  async postV2CommandsSubmitAndWaitRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => SubmitAndWaitResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submit a batch of commands and wait for the completion details
+   */
+  async postV2CommandsSubmitAndWait(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsSubmitAndWaitRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsSubmitAndWaitForReassignment without sending the request
+   */
+  async postV2CommandsSubmitAndWaitForReassignmentRequestOpts(requestParameters) {
+    if (requestParameters["submitAndWaitForReassignmentRequest"] == null) {
+      throw new RequiredError("submitAndWaitForReassignmentRequest", 'Required parameter "submitAndWaitForReassignmentRequest" was null or undefined when calling postV2CommandsSubmitAndWaitForReassignment().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/submit-and-wait-for-reassignment`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: SubmitAndWaitForReassignmentRequestToJSON(requestParameters["submitAndWaitForReassignmentRequest"])
+    };
+  }
+  /**
+   * Submit a batch of reassignment commands and wait for the reassignment response
+   */
+  async postV2CommandsSubmitAndWaitForReassignmentRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitForReassignmentRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsSubmitAndWaitForReassignmentResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submit a batch of reassignment commands and wait for the reassignment response
+   */
+  async postV2CommandsSubmitAndWaitForReassignment(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsSubmitAndWaitForReassignmentRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsSubmitAndWaitForTransaction without sending the request
+   */
+  async postV2CommandsSubmitAndWaitForTransactionRequestOpts(requestParameters) {
+    if (requestParameters["jsSubmitAndWaitForTransactionRequest"] == null) {
+      throw new RequiredError("jsSubmitAndWaitForTransactionRequest", 'Required parameter "jsSubmitAndWaitForTransactionRequest" was null or undefined when calling postV2CommandsSubmitAndWaitForTransaction().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/submit-and-wait-for-transaction`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsSubmitAndWaitForTransactionRequestToJSON(requestParameters["jsSubmitAndWaitForTransactionRequest"])
+    };
+  }
+  /**
+   * Submit a batch of commands and wait for the transaction response
+   */
+  async postV2CommandsSubmitAndWaitForTransactionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitForTransactionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsSubmitAndWaitForTransactionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submit a batch of commands and wait for the transaction response
+   */
+  async postV2CommandsSubmitAndWaitForTransaction(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsSubmitAndWaitForTransactionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsSubmitAndWaitForTransactionTree without sending the request
+   * @deprecated
+   */
+  async postV2CommandsSubmitAndWaitForTransactionTreeRequestOpts(requestParameters) {
+    if (requestParameters["jsCommands"] == null) {
+      throw new RequiredError("jsCommands", 'Required parameter "jsCommands" was null or undefined when calling postV2CommandsSubmitAndWaitForTransactionTree().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/commands/submit-and-wait-for-transaction-tree`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsCommandsToJSON(requestParameters["jsCommands"])
+    };
+  }
+  /**
+   * Submit a batch of commands and wait for the transaction trees response. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use submit-and-wait-for-transaction instead.
+   * @deprecated
+   */
+  async postV2CommandsSubmitAndWaitForTransactionTreeRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitForTransactionTreeRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsSubmitAndWaitForTransactionTreeResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submit a batch of commands and wait for the transaction trees response. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use submit-and-wait-for-transaction instead.
+   * @deprecated
+   */
+  async postV2CommandsSubmitAndWaitForTransactionTree(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsSubmitAndWaitForTransactionTreeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2Dars without sending the request
+   */
+  async postV2DarsRequestOpts(requestParameters) {
+    if (requestParameters["body"] == null) {
+      throw new RequiredError("body", 'Required parameter "body" was null or undefined when calling postV2Dars().');
+    }
+    const queryParameters = {};
+    if (requestParameters["vetAllPackages"] != null) {
+      queryParameters["vetAllPackages"] = requestParameters["vetAllPackages"];
+    }
+    if (requestParameters["synchronizerId"] != null) {
+      queryParameters["synchronizerId"] = requestParameters["synchronizerId"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/octet-stream";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/dars`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    };
+  }
+  /**
+   * Upload a DAR to the participant node
+   */
+  async postV2DarsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2DarsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Upload a DAR to the participant node
+   */
+  async postV2Dars(requestParameters, initOverrides) {
+    const response = await this.postV2DarsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2DarsValidate without sending the request
+   */
+  async postV2DarsValidateRequestOpts(requestParameters) {
+    if (requestParameters["body"] == null) {
+      throw new RequiredError("body", 'Required parameter "body" was null or undefined when calling postV2DarsValidate().');
+    }
+    const queryParameters = {};
+    if (requestParameters["synchronizerId"] != null) {
+      queryParameters["synchronizerId"] = requestParameters["synchronizerId"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/octet-stream";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/dars/validate`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    };
+  }
+  /**
+   * Validates a DAR for upgrade-compatibility against the current vetting state on the target synchronizer
+   */
+  async postV2DarsValidateRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2DarsValidateRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Validates a DAR for upgrade-compatibility against the current vetting state on the target synchronizer
+   */
+  async postV2DarsValidate(requestParameters, initOverrides) {
+    await this.postV2DarsValidateRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Creates request options for postV2EventsEventsByContractId without sending the request
+   */
+  async postV2EventsEventsByContractIdRequestOpts(requestParameters) {
+    if (requestParameters["getEventsByContractIdRequest"] == null) {
+      throw new RequiredError("getEventsByContractIdRequest", 'Required parameter "getEventsByContractIdRequest" was null or undefined when calling postV2EventsEventsByContractId().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/events/events-by-contract-id`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetEventsByContractIdRequestToJSON(requestParameters["getEventsByContractIdRequest"])
+    };
+  }
+  /**
+   * Get events by contract Id
+   */
+  async postV2EventsEventsByContractIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2EventsEventsByContractIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetEventsByContractIdResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get events by contract Id
+   */
+  async postV2EventsEventsByContractId(requestParameters, initOverrides) {
+    const response = await this.postV2EventsEventsByContractIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2Idps without sending the request
+   */
+  async postV2IdpsRequestOpts(requestParameters) {
+    if (requestParameters["createIdentityProviderConfigRequest"] == null) {
+      throw new RequiredError("createIdentityProviderConfigRequest", 'Required parameter "createIdentityProviderConfigRequest" was null or undefined when calling postV2Idps().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/idps`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreateIdentityProviderConfigRequestToJSON(requestParameters["createIdentityProviderConfigRequest"])
+    };
+  }
+  /**
+   * Create identity provider configs
+   */
+  async postV2IdpsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2IdpsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => CreateIdentityProviderConfigResponseFromJSON(jsonValue));
+  }
+  /**
+   * Create identity provider configs
+   */
+  async postV2Idps(requestParameters, initOverrides) {
+    const response = await this.postV2IdpsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2InteractiveSubmissionExecute without sending the request
+   */
+  async postV2InteractiveSubmissionExecuteRequestOpts(requestParameters) {
+    if (requestParameters["jsExecuteSubmissionRequest"] == null) {
+      throw new RequiredError("jsExecuteSubmissionRequest", 'Required parameter "jsExecuteSubmissionRequest" was null or undefined when calling postV2InteractiveSubmissionExecute().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/interactive-submission/execute`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsExecuteSubmissionRequestToJSON(requestParameters["jsExecuteSubmissionRequest"])
+    };
+  }
+  /**
+   * Execute a signed transaction
+   */
+  async postV2InteractiveSubmissionExecuteRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionExecuteRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Execute a signed transaction
+   */
+  async postV2InteractiveSubmissionExecute(requestParameters, initOverrides) {
+    const response = await this.postV2InteractiveSubmissionExecuteRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2InteractiveSubmissionExecuteandwait without sending the request
+   */
+  async postV2InteractiveSubmissionExecuteandwaitRequestOpts(requestParameters) {
+    if (requestParameters["jsExecuteSubmissionAndWaitRequest"] == null) {
+      throw new RequiredError("jsExecuteSubmissionAndWaitRequest", 'Required parameter "jsExecuteSubmissionAndWaitRequest" was null or undefined when calling postV2InteractiveSubmissionExecuteandwait().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/interactive-submission/executeAndWait`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsExecuteSubmissionAndWaitRequestToJSON(requestParameters["jsExecuteSubmissionAndWaitRequest"])
+    };
+  }
+  /**
+   * Execute a signed transaction and wait for its completion
+   */
+  async postV2InteractiveSubmissionExecuteandwaitRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionExecuteandwaitRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ExecuteSubmissionAndWaitResponseFromJSON(jsonValue));
+  }
+  /**
+   * Execute a signed transaction and wait for its completion
+   */
+  async postV2InteractiveSubmissionExecuteandwait(requestParameters, initOverrides) {
+    const response = await this.postV2InteractiveSubmissionExecuteandwaitRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2InteractiveSubmissionExecuteandwaitfortransaction without sending the request
+   */
+  async postV2InteractiveSubmissionExecuteandwaitfortransactionRequestOpts(requestParameters) {
+    if (requestParameters["jsExecuteSubmissionAndWaitForTransactionRequest"] == null) {
+      throw new RequiredError("jsExecuteSubmissionAndWaitForTransactionRequest", 'Required parameter "jsExecuteSubmissionAndWaitForTransactionRequest" was null or undefined when calling postV2InteractiveSubmissionExecuteandwaitfortransaction().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/interactive-submission/executeAndWaitForTransaction`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsExecuteSubmissionAndWaitForTransactionRequestToJSON(requestParameters["jsExecuteSubmissionAndWaitForTransactionRequest"])
+    };
+  }
+  /**
+   * Execute a signed transaction and wait for the transaction response
+   */
+  async postV2InteractiveSubmissionExecuteandwaitfortransactionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionExecuteandwaitfortransactionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsExecuteSubmissionAndWaitForTransactionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Execute a signed transaction and wait for the transaction response
+   */
+  async postV2InteractiveSubmissionExecuteandwaitfortransaction(requestParameters, initOverrides) {
+    const response = await this.postV2InteractiveSubmissionExecuteandwaitfortransactionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2InteractiveSubmissionPreferredPackages without sending the request
+   */
+  async postV2InteractiveSubmissionPreferredPackagesRequestOpts(requestParameters) {
+    if (requestParameters["getPreferredPackagesRequest"] == null) {
+      throw new RequiredError("getPreferredPackagesRequest", 'Required parameter "getPreferredPackagesRequest" was null or undefined when calling postV2InteractiveSubmissionPreferredPackages().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/interactive-submission/preferred-packages`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetPreferredPackagesRequestToJSON(requestParameters["getPreferredPackagesRequest"])
+    };
+  }
+  /**
+   * Get the version of preferred packages for constructing a command submission
+   */
+  async postV2InteractiveSubmissionPreferredPackagesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionPreferredPackagesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetPreferredPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get the version of preferred packages for constructing a command submission
+   */
+  async postV2InteractiveSubmissionPreferredPackages(requestParameters, initOverrides) {
+    const response = await this.postV2InteractiveSubmissionPreferredPackagesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2InteractiveSubmissionPrepare without sending the request
+   */
+  async postV2InteractiveSubmissionPrepareRequestOpts(requestParameters) {
+    if (requestParameters["jsPrepareSubmissionRequest"] == null) {
+      throw new RequiredError("jsPrepareSubmissionRequest", 'Required parameter "jsPrepareSubmissionRequest" was null or undefined when calling postV2InteractiveSubmissionPrepare().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/interactive-submission/prepare`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: JsPrepareSubmissionRequestToJSON(requestParameters["jsPrepareSubmissionRequest"])
+    };
+  }
+  /**
+   * Prepare commands for signing
+   */
+  async postV2InteractiveSubmissionPrepareRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionPrepareRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsPrepareSubmissionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Prepare commands for signing
+   */
+  async postV2InteractiveSubmissionPrepare(requestParameters, initOverrides) {
+    const response = await this.postV2InteractiveSubmissionPrepareRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2PackageVetting without sending the request
+   */
+  async postV2PackageVettingRequestOpts(requestParameters) {
+    if (requestParameters["updateVettedPackagesRequest"] == null) {
+      throw new RequiredError("updateVettedPackagesRequest", 'Required parameter "updateVettedPackagesRequest" was null or undefined when calling postV2PackageVetting().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/package-vetting`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateVettedPackagesRequestToJSON(requestParameters["updateVettedPackagesRequest"])
+    };
+  }
+  /**
+   * Update vetted packages
+   */
+  async postV2PackageVettingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PackageVettingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdateVettedPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Update vetted packages
+   */
+  async postV2PackageVetting(requestParameters, initOverrides) {
+    const response = await this.postV2PackageVettingRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2Packages without sending the request
+   */
+  async postV2PackagesRequestOpts(requestParameters) {
+    if (requestParameters["body"] == null) {
+      throw new RequiredError("body", 'Required parameter "body" was null or undefined when calling postV2Packages().');
+    }
+    const queryParameters = {};
+    if (requestParameters["vetAllPackages"] != null) {
+      queryParameters["vetAllPackages"] = requestParameters["vetAllPackages"];
+    }
+    if (requestParameters["synchronizerId"] != null) {
+      queryParameters["synchronizerId"] = requestParameters["synchronizerId"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/octet-stream";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/packages`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    };
+  }
+  /**
+   * Upload a DAR to the participant node. Behaves the same as /dars. This endpoint will be deprecated and removed in a future release.
+   */
+  async postV2PackagesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PackagesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Upload a DAR to the participant node. Behaves the same as /dars. This endpoint will be deprecated and removed in a future release.
+   */
+  async postV2Packages(requestParameters, initOverrides) {
+    const response = await this.postV2PackagesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2Parties without sending the request
+   */
+  async postV2PartiesRequestOpts(requestParameters) {
+    if (requestParameters["allocatePartyRequest"] == null) {
+      throw new RequiredError("allocatePartyRequest", 'Required parameter "allocatePartyRequest" was null or undefined when calling postV2Parties().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: AllocatePartyRequestToJSON(requestParameters["allocatePartyRequest"])
+    };
+  }
+  /**
+   * Allocate a new party to the participant node
+   */
+  async postV2PartiesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PartiesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => AllocatePartyResponseFromJSON(jsonValue));
+  }
+  /**
+   * Allocate a new party to the participant node
+   */
+  async postV2Parties(requestParameters, initOverrides) {
+    const response = await this.postV2PartiesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2PartiesExternalAllocate without sending the request
+   */
+  async postV2PartiesExternalAllocateRequestOpts(requestParameters) {
+    if (requestParameters["allocateExternalPartyRequest"] == null) {
+      throw new RequiredError("allocateExternalPartyRequest", 'Required parameter "allocateExternalPartyRequest" was null or undefined when calling postV2PartiesExternalAllocate().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties/external/allocate`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: AllocateExternalPartyRequestToJSON(requestParameters["allocateExternalPartyRequest"])
+    };
+  }
+  /**
+   * Allocate a new external party
+   */
+  async postV2PartiesExternalAllocateRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PartiesExternalAllocateRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => AllocateExternalPartyResponseFromJSON(jsonValue));
+  }
+  /**
+   * Allocate a new external party
+   */
+  async postV2PartiesExternalAllocate(requestParameters, initOverrides) {
+    const response = await this.postV2PartiesExternalAllocateRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2PartiesExternalGenerateTopology without sending the request
+   */
+  async postV2PartiesExternalGenerateTopologyRequestOpts(requestParameters) {
+    if (requestParameters["generateExternalPartyTopologyRequest"] == null) {
+      throw new RequiredError("generateExternalPartyTopologyRequest", 'Required parameter "generateExternalPartyTopologyRequest" was null or undefined when calling postV2PartiesExternalGenerateTopology().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/parties/external/generate-topology`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GenerateExternalPartyTopologyRequestToJSON(requestParameters["generateExternalPartyTopologyRequest"])
+    };
+  }
+  /**
+   * Generate a topology for an external party
+   */
+  async postV2PartiesExternalGenerateTopologyRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PartiesExternalGenerateTopologyRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GenerateExternalPartyTopologyResponseFromJSON(jsonValue));
+  }
+  /**
+   * Generate a topology for an external party
+   */
+  async postV2PartiesExternalGenerateTopology(requestParameters, initOverrides) {
+    const response = await this.postV2PartiesExternalGenerateTopologyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2StateActiveContracts without sending the request
+   */
+  async postV2StateActiveContractsRequestOpts(requestParameters) {
+    if (requestParameters["getActiveContractsRequest"] == null) {
+      throw new RequiredError("getActiveContractsRequest", 'Required parameter "getActiveContractsRequest" was null or undefined when calling postV2StateActiveContracts().');
+    }
+    const queryParameters = {};
+    if (requestParameters["limit"] != null) {
+      queryParameters["limit"] = requestParameters["limit"];
+    }
+    if (requestParameters["streamIdleTimeoutMs"] != null) {
+      queryParameters["stream_idle_timeout_ms"] = requestParameters["streamIdleTimeoutMs"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/state/active-contracts`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetActiveContractsRequestToJSON(requestParameters["getActiveContractsRequest"])
+    };
+  }
+  /**
+   * Query active contracts list (blocking call). Querying active contracts is an expensive operation and if possible should not be repeated often. Consider querying active contracts initially (for a given offset) and then repeatedly call one of `/v2/updates/...`endpoints  to get subsequent modifications. You can also use websockets to get updates with better performance.  Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   */
+  async postV2StateActiveContractsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2StateActiveContractsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(JsGetActiveContractsResponseFromJSON));
+  }
+  /**
+   * Query active contracts list (blocking call). Querying active contracts is an expensive operation and if possible should not be repeated often. Consider querying active contracts initially (for a given offset) and then repeatedly call one of `/v2/updates/...`endpoints  to get subsequent modifications. You can also use websockets to get updates with better performance.  Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   */
+  async postV2StateActiveContracts(requestParameters, initOverrides) {
+    const response = await this.postV2StateActiveContractsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2Updates without sending the request
+   */
+  async postV2UpdatesRequestOpts(requestParameters) {
+    if (requestParameters["getUpdatesRequest"] == null) {
+      throw new RequiredError("getUpdatesRequest", 'Required parameter "getUpdatesRequest" was null or undefined when calling postV2Updates().');
+    }
+    const queryParameters = {};
+    if (requestParameters["limit"] != null) {
+      queryParameters["limit"] = requestParameters["limit"];
+    }
+    if (requestParameters["streamIdleTimeoutMs"] != null) {
+      queryParameters["stream_idle_timeout_ms"] = requestParameters["streamIdleTimeoutMs"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdatesRequestToJSON(requestParameters["getUpdatesRequest"])
+    };
+  }
+  /**
+   * Query updates list (blocking call) Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   */
+  async postV2UpdatesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(JsGetUpdatesResponseFromJSON));
+  }
+  /**
+   * Query updates list (blocking call) Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   */
+  async postV2Updates(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesFlats without sending the request
+   * @deprecated
+   */
+  async postV2UpdatesFlatsRequestOpts(requestParameters) {
+    if (requestParameters["getUpdatesRequest"] == null) {
+      throw new RequiredError("getUpdatesRequest", 'Required parameter "getUpdatesRequest" was null or undefined when calling postV2UpdatesFlats().');
+    }
+    const queryParameters = {};
+    if (requestParameters["limit"] != null) {
+      queryParameters["limit"] = requestParameters["limit"];
+    }
+    if (requestParameters["streamIdleTimeoutMs"] != null) {
+      queryParameters["stream_idle_timeout_ms"] = requestParameters["streamIdleTimeoutMs"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/flats`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdatesRequestToJSON(requestParameters["getUpdatesRequest"])
+    };
+  }
+  /**
+   * Query flat transactions update list (blocking call). Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates instead. Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   * @deprecated
+   */
+  async postV2UpdatesFlatsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesFlatsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(JsGetUpdatesResponseFromJSON));
+  }
+  /**
+   * Query flat transactions update list (blocking call). Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates instead. Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   * @deprecated
+   */
+  async postV2UpdatesFlats(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesFlatsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesTransactionById without sending the request
+   * @deprecated
+   */
+  async postV2UpdatesTransactionByIdRequestOpts(requestParameters) {
+    if (requestParameters["getTransactionByIdRequest"] == null) {
+      throw new RequiredError("getTransactionByIdRequest", 'Required parameter "getTransactionByIdRequest" was null or undefined when calling postV2UpdatesTransactionById().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/transaction-by-id`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetTransactionByIdRequestToJSON(requestParameters["getTransactionByIdRequest"])
+    };
+  }
+  /**
+   * Get transaction by id. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-id instead.
+   * @deprecated
+   */
+  async postV2UpdatesTransactionByIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesTransactionByIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetTransactionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get transaction by id. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-id instead.
+   * @deprecated
+   */
+  async postV2UpdatesTransactionById(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesTransactionByIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesTransactionByOffset without sending the request
+   * @deprecated
+   */
+  async postV2UpdatesTransactionByOffsetRequestOpts(requestParameters) {
+    if (requestParameters["getTransactionByOffsetRequest"] == null) {
+      throw new RequiredError("getTransactionByOffsetRequest", 'Required parameter "getTransactionByOffsetRequest" was null or undefined when calling postV2UpdatesTransactionByOffset().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/transaction-by-offset`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetTransactionByOffsetRequestToJSON(requestParameters["getTransactionByOffsetRequest"])
+    };
+  }
+  /**
+   * Get transaction by offset. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-offset instead.
+   * @deprecated
+   */
+  async postV2UpdatesTransactionByOffsetRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesTransactionByOffsetRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetTransactionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get transaction by offset. Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates/update-by-offset instead.
+   * @deprecated
+   */
+  async postV2UpdatesTransactionByOffset(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesTransactionByOffsetRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesTrees without sending the request
+   * @deprecated
+   */
+  async postV2UpdatesTreesRequestOpts(requestParameters) {
+    if (requestParameters["getUpdatesRequest"] == null) {
+      throw new RequiredError("getUpdatesRequest", 'Required parameter "getUpdatesRequest" was null or undefined when calling postV2UpdatesTrees().');
+    }
+    const queryParameters = {};
+    if (requestParameters["limit"] != null) {
+      queryParameters["limit"] = requestParameters["limit"];
+    }
+    if (requestParameters["streamIdleTimeoutMs"] != null) {
+      queryParameters["stream_idle_timeout_ms"] = requestParameters["streamIdleTimeoutMs"];
+    }
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/trees`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdatesRequestToJSON(requestParameters["getUpdatesRequest"])
+    };
+  }
+  /**
+   * Query update transactions tree list (blocking call). Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates instead. Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   * @deprecated
+   */
+  async postV2UpdatesTreesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesTreesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(JsGetUpdateTreesResponseFromJSON));
+  }
+  /**
+   * Query update transactions tree list (blocking call). Provided for backwards compatibility, it will be removed in the Canton version 3.5.0, use v2/updates instead. Notice: This endpoint should be used for small results set. When number of results exceeded node configuration limit (`http-list-max-elements-limit`) there will be an error (`413 Content Too Large`) returned. Increasing this limit may lead to performance issues and high memory consumption. Consider using websockets (asyncapi) for better efficiency with larger results.
+   * @deprecated
+   */
+  async postV2UpdatesTrees(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesTreesRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesUpdateById without sending the request
+   */
+  async postV2UpdatesUpdateByIdRequestOpts(requestParameters) {
+    if (requestParameters["getUpdateByIdRequest"] == null) {
+      throw new RequiredError("getUpdateByIdRequest", 'Required parameter "getUpdateByIdRequest" was null or undefined when calling postV2UpdatesUpdateById().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/update-by-id`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdateByIdRequestToJSON(requestParameters["getUpdateByIdRequest"])
+    };
+  }
+  /**
+   * Get update by id
+   */
+  async postV2UpdatesUpdateByIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesUpdateByIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetUpdateResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get update by id
+   */
+  async postV2UpdatesUpdateById(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesUpdateByIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesUpdateByOffset without sending the request
+   */
+  async postV2UpdatesUpdateByOffsetRequestOpts(requestParameters) {
+    if (requestParameters["getUpdateByOffsetRequest"] == null) {
+      throw new RequiredError("getUpdateByOffsetRequest", 'Required parameter "getUpdateByOffsetRequest" was null or undefined when calling postV2UpdatesUpdateByOffset().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/updates/update-by-offset`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdateByOffsetRequestToJSON(requestParameters["getUpdateByOffsetRequest"])
+    };
+  }
+  /**
+   * Get update by offset
+   */
+  async postV2UpdatesUpdateByOffsetRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesUpdateByOffsetRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetUpdateResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get update by offset
+   */
+  async postV2UpdatesUpdateByOffset(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesUpdateByOffsetRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2Users without sending the request
+   */
+  async postV2UsersRequestOpts(requestParameters) {
+    if (requestParameters["createUserRequest"] == null) {
+      throw new RequiredError("createUserRequest", 'Required parameter "createUserRequest" was null or undefined when calling postV2Users().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreateUserRequestToJSON(requestParameters["createUserRequest"])
+    };
+  }
+  /**
+   * Create user.
+   */
+  async postV2UsersRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UsersRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => CreateUserResponseFromJSON(jsonValue));
+  }
+  /**
+   * Create user.
+   */
+  async postV2Users(requestParameters, initOverrides) {
+    const response = await this.postV2UsersRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UsersUserIdRights without sending the request
+   */
+  async postV2UsersUserIdRightsRequestOpts(requestParameters) {
+    if (requestParameters["userId"] == null) {
+      throw new RequiredError("userId", 'Required parameter "userId" was null or undefined when calling postV2UsersUserIdRights().');
+    }
+    if (requestParameters["grantUserRightsRequest"] == null) {
+      throw new RequiredError("grantUserRightsRequest", 'Required parameter "grantUserRightsRequest" was null or undefined when calling postV2UsersUserIdRights().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("httpAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    if (this.configuration && this.configuration.apiKey) {
+      headerParameters["Sec-WebSocket-Protocol"] = await this.configuration.apiKey("Sec-WebSocket-Protocol");
+    }
+    let urlPath = `/v2/users/{user-id}/rights`;
+    urlPath = urlPath.replace(`{${"user-id"}}`, encodeURIComponent(String(requestParameters["userId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GrantUserRightsRequestToJSON(requestParameters["grantUserRightsRequest"])
+    };
+  }
+  /**
+   * Grant user rights.
+   */
+  async postV2UsersUserIdRightsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UsersUserIdRightsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GrantUserRightsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Grant user rights.
+   */
+  async postV2UsersUserIdRights(requestParameters, initOverrides) {
+    const response = await this.postV2UsersUserIdRightsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+export { DefaultApi };
+//# sourceMappingURL=GJFARMTH.js.map
+//# sourceMappingURL=GJFARMTH.js.map