@layerzerolabs/common-canton 1.2.76 → 1.2.77

package/dist/DYK7UQLE.js

@@ -0,0 +1,2960 @@
+import { UpdateUserIdentityProviderIdRequestToJSON } from './3L6H225P.js';
+import { UpdateUserRequestToJSON } from './ZHFFNA6T.js';
+import { UpdateUserResponseFromJSON } from './27NTN7DJ.js';
+import { UpdateVettedPackagesRequestToJSON } from './N6YQSSHF.js';
+import { UpdateVettedPackagesResponseFromJSON } from './5OMVLESZ.js';
+import { UpdateIdentityProviderConfigRequestToJSON } from './73ZQLGAW.js';
+import { UpdateIdentityProviderConfigResponseFromJSON } from './BEUUOZIE.js';
+import { UpdatePartyDetailsRequestToJSON } from './YFFXQMOW.js';
+import { UpdatePartyDetailsResponseFromJSON } from './V7JJHOPQ.js';
+import { UpdateAccountRequestToJSON } from './WQ2D4LIQ.js';
+import { UpdateAccountResponseFromJSON } from './YTK6MI37.js';
+import { SubmitAndWaitResponseFromJSON } from './2AGMTUWQ.js';
+import { SubmitReassignmentRequestToJSON } from './JHYA3YSD.js';
+import { SubmitAndWaitForReassignmentRequestToJSON } from './3JL644IZ.js';
+import { RevokeUserRightsRequestToJSON } from './Q4D2T7BS.js';
+import { RevokeUserRightsResponseFromJSON } from './DR3COIEJ.js';
+import { PruneEventsRequestToJSON } from './ZSWCYSBS.js';
+import { PruneEventsResponseFromJSON } from './RD4LJTM6.js';
+import { ListKnownPartiesResponseFromJSON } from './ES43SA6S.js';
+import { ListPackagesResponseFromJSON } from './KLBLHAAZ.js';
+import { ListUserRightsResponseFromJSON } from './XCOCX2NQ.js';
+import { ListUsersResponseFromJSON } from './W4Y2EVIC.js';
+import { ListVettedPackagesRequestToJSON } from './HVHDGJQO.js';
+import { ListVettedPackagesResponseFromJSON } from './XPBWLE4B.js';
+import { ListIdentityProviderConfigsResponseFromJSON } from './UCA2MJKV.js';
+import { JsSubmitAndWaitForTransactionRequestToJSON } from './IDBCBX2F.js';
+import { JsSubmitAndWaitForTransactionResponseFromJSON } from './3KBNHKU6.js';
+import { JsPrepareSubmissionRequestToJSON } from './DX46ASEP.js';
+import { JsPrepareSubmissionResponseFromJSON } from './DO7HNWSI.js';
+import { JsSubmitAndWaitForReassignmentResponseFromJSON } from './VIT2NCYV.js';
+import { JsGetEventsByContractIdResponseFromJSON } from './UCJV5L2R.js';
+import { JsGetUpdatesPageResponseFromJSON } from './7AWXDEJN.js';
+import { JsGetUpdateResponseFromJSON } from './ENHZYE4Z.js';
+import { JsGetUpdatesResponseFromJSON } from './MISBG67G.js';
+import { JsExecuteSubmissionAndWaitForTransactionRequestToJSON } from './W5JSNM4P.js';
+import { JsExecuteSubmissionAndWaitForTransactionResponseFromJSON } from './KPHXDZAV.js';
+import { JsExecuteSubmissionAndWaitRequestToJSON } from './37KTIK6O.js';
+import { JsExecuteSubmissionRequestToJSON } from './ICIMAW3A.js';
+import { JsGetActiveContractsPageResponseFromJSON } from './F7CLAJVB.js';
+import { JsGetActiveContractsResponseFromJSON } from './M6FSENHW.js';
+import { JsCommandsToJSON } from './YIP3DFVS.js';
+import { GetUpdatesPageRequestToJSON } from './ULT5A5TC.js';
+import { GetUpdatesRequestToJSON } from './RIREEIYO.js';
+import { GetUserResponseFromJSON } from './6RTWPQMC.js';
+import { GetV2JoseJwks200ResponseFromJSON } from './LWOYH75Z.js';
+import { GrantUserRightsRequestToJSON } from './L26PC3MC.js';
+import { GrantUserRightsResponseFromJSON } from './Q5QMWEOQ.js';
+import { GetPackageStatusResponseFromJSON } from './LH7QXGFS.js';
+import { GetParticipantIdResponseFromJSON } from './EXSOIAFY.js';
+import { GetPartiesResponseFromJSON } from './P6O2T7ZW.js';
+import { GetPreferredPackagesRequestToJSON } from './4PAYBJUW.js';
+import { GetPreferredPackagesResponseFromJSON } from './PYDVF42B.js';
+import { GetUpdateByHashRequestToJSON } from './AFZOQGRN.js';
+import { GetUpdateByIdRequestToJSON } from './QLSD7CDL.js';
+import { GetUpdateByOffsetRequestToJSON } from './3NNZDKUQ.js';
+import { GetConnectedSynchronizersResponseFromJSON } from './EP2G7H6I.js';
+import { GetContractRequestToJSON } from './V6FCAPUU.js';
+import { GetContractResponseFromJSON } from './4OAANFT3.js';
+import { GetEventsByContractIdRequestToJSON } from './BIHZXZGJ.js';
+import { GetIdentityProviderConfigResponseFromJSON } from './WKLWGHNT.js';
+import { GetLatestPrunedOffsetsResponseFromJSON } from './B3UVNBBP.js';
+import { GetLedgerApiVersionResponseFromJSON } from './O4AMCIVA.js';
+import { GetLedgerEndResponseFromJSON } from './4DQ3RHPY.js';
+import { GenerateExternalPartyTopologyRequestToJSON } from './ZEGRO3QT.js';
+import { GenerateExternalPartyTopologyResponseFromJSON } from './AUEILPFH.js';
+import { GetAccountResponseFromJSON } from './OPCK4OIY.js';
+import { GetActiveContractsPageRequestToJSON } from './Q7L2ADEU.js';
+import { GetActiveContractsRequestToJSON } from './7AX6ETEC.js';
+import { GetCompletionByHashRequestToJSON } from './FG5GEAHJ.js';
+import { GetCompletionByHashResponseFromJSON } from './FO4X6Q5A.js';
+import { GetCompletionsRequestToJSON } from './OLJFWRKS.js';
+import { ExecuteSubmissionAndWaitResponseFromJSON } from './WOKR3MJN.js';
+import { CreateIdentityProviderConfigRequestToJSON } from './NSWQYLVP.js';
+import { CreateIdentityProviderConfigResponseFromJSON } from './WOMNRJVY.js';
+import { CreateUserRequestToJSON } from './X5KMH3AN.js';
+import { CreateUserResponseFromJSON } from './RITMDRAF.js';
+import { CompletionStreamRequestToJSON } from './YWT6EWQM.js';
+import { CompletionStreamResponseFromJSON } from './O25T2HOW.js';
+import { ConvertRecordTimeToOffsetResponseFromJSON } from './YZ7VPFFP.js';
+import { AllocateExternalPartyRequestToJSON } from './44RZIZXM.js';
+import { AllocateExternalPartyResponseFromJSON } from './YLTVVUUX.js';
+import { AllocatePartyRequestToJSON } from './FGFEMG3G.js';
+import { AllocatePartyResponseFromJSON } from './CQF7HUL6.js';
+import { BaseAPI, RequiredError, JSONApiResponse, VoidApiResponse, TextApiResponse, BlobApiResponse, serializeDateTime } from './XVX7EVTW.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 an existing identity provider configuration.
+   */
+  async deleteV2IdpsIdpIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteV2IdpsIdpIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Delete an existing identity provider configuration.
+   */
+  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 an existing user and all its rights.
+   */
+  async deleteV2UsersUserIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteV2UsersUserIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Delete an existing user and all its rights.
+   */
+  async deleteV2UsersUserId(requestParameters, initOverrides) {
+    const response = await this.deleteV2UsersUserIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getLivez without sending the request
+   */
+  async getLivezRequestOpts() {
+    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 = `/livez`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Checks if the service is alive
+   */
+  async getLivezRaw(initOverrides) {
+    const requestOptions = await this.getLivezRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Checks if the service is alive
+   */
+  async getLivez(initOverrides) {
+    await this.getLivezRaw(initOverrides);
+  }
+  /**
+   * Creates request options for getReadyz without sending the request
+   */
+  async getReadyzRequestOpts() {
+    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 = `/readyz`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Checks if the service is ready to serve requests
+   */
+  async getReadyzRaw(initOverrides) {
+    const requestOptions = await this.getReadyzRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Checks if the service is ready to serve requests
+   */
+  async getReadyz(initOverrides) {
+    const response = await this.getReadyzRaw(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 the user data of the current authenticated user.
+   */
+  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 the user data of the current authenticated user.
+   */
+  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 existing identity provider configurations.
+   */
+  async getV2IdpsRaw(initOverrides) {
+    const requestOptions = await this.getV2IdpsRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListIdentityProviderConfigsResponseFromJSON(jsonValue));
+  }
+  /**
+   * List all existing identity provider configurations.
+   */
+  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 the identity provider configuration data by id.
+   */
+  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 the identity provider configuration data by id.
+   */
+  async getV2IdpsIdpId(requestParameters, initOverrides) {
+    const response = await this.getV2IdpsIdpIdRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2JoseJwks without sending the request
+   */
+  async getV2JoseJwksRequestOpts(requestParameters) {
+    if (requestParameters["synchronizer"] == null) {
+      throw new RequiredError("synchronizer", 'Required parameter "synchronizer" was null or undefined when calling getV2JoseJwks().');
+    }
+    if (requestParameters["party"] == null) {
+      throw new RequiredError("party", 'Required parameter "party" was null or undefined when calling getV2JoseJwks().');
+    }
+    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/jose/jwks/synchronizer/{synchronizer}/party/{party}`;
+    urlPath = urlPath.replace("{synchronizer}", encodeURIComponent(String(requestParameters["synchronizer"])));
+    urlPath = urlPath.replace("{party}", encodeURIComponent(String(requestParameters["party"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Retrieve public keys as JWKS for a specific party and synchronizer. This endpoint is experimental / alpha, therefore no backwards compatibility is guaranteed.
+   */
+  async getV2JoseJwksRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2JoseJwksRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetV2JoseJwks200ResponseFromJSON(jsonValue));
+  }
+  /**
+   * Retrieve public keys as JWKS for a specific party and synchronizer. This endpoint is experimental / alpha, therefore no backwards compatibility is guaranteed.
+   */
+  async getV2JoseJwks(requestParameters, initOverrides) {
+    const response = await this.getV2JoseJwksRaw(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
+    };
+  }
+  /**
+   * Returns the identifiers of all supported packages.
+   */
+  async getV2PackagesRaw(initOverrides) {
+    const requestOptions = await this.getV2PackagesRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Returns the identifiers of all supported packages.
+   */
+  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
+    };
+  }
+  /**
+   * Returns the contents of a single package.
+   */
+  async getV2PackagesPackageIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PackagesPackageIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new BlobApiResponse(response);
+  }
+  /**
+   * Returns the contents of a single package.
+   */
+  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
+    };
+  }
+  /**
+   * Returns the status of a single package.
+   */
+  async getV2PackagesPackageIdStatusRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2PackagesPackageIdStatusRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetPackageStatusResponseFromJSON(jsonValue));
+  }
+  /**
+   * Returns the status of a single package.
+   */
+  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["identityProviderId"] != null) {
+      queryParameters["identity-provider-id"] = requestParameters["identityProviderId"];
+    }
+    if (requestParameters["filterParty"] != null) {
+      queryParameters["filter-party"] = requestParameters["filterParty"];
+    }
+    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 the parties known by the participant. The list returned contains parties whose ledger access is facilitated by the participant and the ones maintained elsewhere.
+   */
+  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 the parties known by the participant. The list returned contains parties whose ledger access is facilitated by the participant and the ones maintained elsewhere.
+   */
+  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
+    };
+  }
+  /**
+   * Return the identifier of the participant. All horizontally scaled replicas should return the same id. daml-on-kv-ledger: returns an identifier supplied on command line at launch time canton: returns globally unique identifier of the participant
+   */
+  async getV2PartiesParticipantIdRaw(initOverrides) {
+    const requestOptions = await this.getV2PartiesParticipantIdRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetParticipantIdResponseFromJSON(jsonValue));
+  }
+  /**
+   * Return the identifier of the participant. All horizontally scaled replicas should return the same id. daml-on-kv-ledger: returns an identifier supplied on command line at launch time canton: returns globally unique identifier of the participant
+   */
+  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 the party details of the given parties. Only known parties will be returned in the list.
+   */
+  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 the party details of the given parties. Only known parties will be returned in the list.
+   */
+  async getV2PartiesParty(requestParameters, initOverrides) {
+    const response = await this.getV2PartiesPartyRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2StateActiveContractsPage without sending the request
+   * @deprecated
+   */
+  async getV2StateActiveContractsPageRequestOpts(requestParameters) {
+    if (requestParameters["getActiveContractsPageRequest"] == null) {
+      throw new RequiredError("getActiveContractsPageRequest", 'Required parameter "getActiveContractsPageRequest" was null or undefined when calling getV2StateActiveContractsPage().');
+    }
+    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/state/active-contracts-page`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetActiveContractsPageRequestToJSON(requestParameters["getActiveContractsPageRequest"])
+    };
+  }
+  /**
+   * Deprecated  Use POST version of this endpoint
+   * @deprecated
+   */
+  async getV2StateActiveContractsPageRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2StateActiveContractsPageRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetActiveContractsPageResponseFromJSON(jsonValue));
+  }
+  /**
+   * Deprecated  Use POST version of this endpoint
+   * @deprecated
+   */
+  async getV2StateActiveContractsPage(requestParameters, initOverrides) {
+    const response = await this.getV2StateActiveContractsPageRaw(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 the list of connected synchronizers at the time of the query.
+   */
+  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 the list of connected synchronizers at the time of the query.
+   */
+  async getV2StateConnectedSynchronizers(requestParameters = {}, initOverrides) {
+    const response = await this.getV2StateConnectedSynchronizersRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2StateConvertRecordTimeToOffset without sending the request
+   */
+  async getV2StateConvertRecordTimeToOffsetRequestOpts(requestParameters) {
+    if (requestParameters["recordTime"] == null) {
+      throw new RequiredError("recordTime", 'Required parameter "recordTime" was null or undefined when calling getV2StateConvertRecordTimeToOffset().');
+    }
+    const queryParameters = {};
+    if (requestParameters["recordTime"] != null) {
+      queryParameters["record-time"] = serializeDateTime(requestParameters["recordTime"]);
+    }
+    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/state/convert-record-time-to-offset`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Translate syncrhonizer record time to an offset If the requested record time is earlier that the earliest record time known for the given synchronizer (either because is is before the connection to the synchronizer was established or because it was already pruned), the request fails with RECORD_TIME_NOT_FOUND error. If the requested record time is after the latest record time observed for this synchronizer, the request fails with RECORD_TIME_NOT_OBSERVED_YET error code. This may be transitional condition until participant node catches up with most recent synchronizer updates. In such case the caller may retry this request.
+   */
+  async getV2StateConvertRecordTimeToOffsetRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2StateConvertRecordTimeToOffsetRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ConvertRecordTimeToOffsetResponseFromJSON(jsonValue));
+  }
+  /**
+   * Translate syncrhonizer record time to an offset If the requested record time is earlier that the earliest record time known for the given synchronizer (either because is is before the connection to the synchronizer was established or because it was already pruned), the request fails with RECORD_TIME_NOT_FOUND error. If the requested record time is after the latest record time observed for this synchronizer, the request fails with RECORD_TIME_NOT_OBSERVED_YET error code. This may be transitional condition until participant node catches up with most recent synchronizer updates. In such case the caller may retry this request.
+   */
+  async getV2StateConvertRecordTimeToOffset(requestParameters, initOverrides) {
+    const response = await this.getV2StateConvertRecordTimeToOffsetRaw(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 the latest successfully pruned ledger offsets
+   */
+  async getV2StateLatestPrunedOffsetsRaw(initOverrides) {
+    const requestOptions = await this.getV2StateLatestPrunedOffsetsRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetLatestPrunedOffsetsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get the latest successfully pruned ledger 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(requestParameters) {
+    const queryParameters = {};
+    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/state/ledger-end`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get the current ledger end. Subscriptions started with the returned offset will serve events after this RPC was called.
+   */
+  async getV2StateLedgerEndRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2StateLedgerEndRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetLedgerEndResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get the current ledger end. Subscriptions started with the returned offset will serve events after this RPC was called.
+   */
+  async getV2StateLedgerEnd(requestParameters = {}, initOverrides) {
+    const response = await this.getV2StateLedgerEndRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getV2TrafficAccountsAccountId without sending the request
+   */
+  async getV2TrafficAccountsAccountIdRequestOpts(requestParameters) {
+    if (requestParameters["accountId"] == null) {
+      throw new RequiredError("accountId", 'Required parameter "accountId" was null or undefined when calling getV2TrafficAccountsAccountId().');
+    }
+    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/traffic/accounts/{account-id}`;
+    urlPath = urlPath.replace("{account-id}", encodeURIComponent(String(requestParameters["accountId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get account state for a given account ID. Permissioned only to users having ActAs or ExecuteAs rights for the party ID associated with the account ID.  NOTE: This endpoint is exposed only when traffic enforcement feature is enabled (canton.participants.participant1.traffic-enforcement.enabled = true)
+   */
+  async getV2TrafficAccountsAccountIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getV2TrafficAccountsAccountIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetAccountResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get account state for a given account ID. Permissioned only to users having ActAs or ExecuteAs rights for the party ID associated with the account ID.  NOTE: This endpoint is exposed only when traffic enforcement feature is enabled (canton.participants.participant1.traffic-enforcement.enabled = true)
+   */
+  async getV2TrafficAccountsAccountId(requestParameters, initOverrides) {
+    const response = await this.getV2TrafficAccountsAccountIdRaw(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 existing 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 existing 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 the user data of a specific user or the authenticated user.
+   */
+  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 the user data of a specific user or the authenticated user.
+   */
+  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 the set of all rights granted to a user.
+   */
+  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 the set of all rights granted to a user.
+   */
+  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
+    };
+  }
+  /**
+   * Read the Ledger API version
+   */
+  async getV2VersionRaw(initOverrides) {
+    const requestOptions = await this.getV2VersionRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetLedgerApiVersionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Read the Ledger API version
+   */
+  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 selected modifiable attribute of an identity provider config resource described by the ``IdentityProviderConfig`` message.
+   */
+  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 selected modifiable attribute of an identity provider config resource described by the ``IdentityProviderConfig`` message.
+   */
+  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"])
+    };
+  }
+  /**
+   * Update selected modifiable participant-local attributes of a party details resource. Can update the participant\'s local information for local parties.
+   */
+  async patchV2PartiesPartyRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2PartiesPartyRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdatePartyDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Update selected modifiable participant-local attributes of a party details resource. Can update the participant\'s local information for local parties.
+   */
+  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 selected modifiable attribute of a user resource described by the ``User`` message.
+   */
+  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 selected modifiable attribute of a user resource described by the ``User`` message.
+   */
+  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 the assignment of a user from one IDP to another.
+   */
+  async patchV2UsersUserIdIdentityProviderIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.patchV2UsersUserIdIdentityProviderIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Update the assignment of a user from one IDP to another.
+   */
+  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 rights from a user. Revoking rights does not affect the resource version of the corresponding user.
+   */
+  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 rights from a user. Revoking rights does not affect the resource version of the corresponding user.
+   */
+  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 single composite command.
+   */
+  async postV2CommandsAsyncSubmitRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsAsyncSubmitRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Submit a single composite command.
+   */
+  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 a single reassignment.
+   */
+  async postV2CommandsAsyncSubmitReassignmentRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsAsyncSubmitReassignmentRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Submit a single reassignment.
+   */
+  async postV2CommandsAsyncSubmitReassignment(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsAsyncSubmitReassignmentRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsCommandCompletions without sending the request
+   */
+  async postV2CommandsCommandCompletionsRequestOpts(requestParameters) {
+    if (requestParameters["getCompletionsRequest"] == null) {
+      throw new RequiredError("getCompletionsRequest", 'Required parameter "getCompletionsRequest" was null or undefined when calling postV2CommandsCommandCompletions().');
+    }
+    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/command-completions`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetCompletionsRequestToJSON(requestParameters["getCompletionsRequest"])
+    };
+  }
+  /**
+   * Query completions list (blocking call)  Subscribe to command completion events. This streaming endpoint provides more flexibility in filtering than the predecessor ``CompletionStream``. 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 postV2CommandsCommandCompletionsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsCommandCompletionsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(CompletionStreamResponseFromJSON));
+  }
+  /**
+   * Query completions list (blocking call)  Subscribe to command completion events. This streaming endpoint provides more flexibility in filtering than the predecessor ``CompletionStream``. 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 postV2CommandsCommandCompletions(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsCommandCompletionsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2CommandsCompletionByHash without sending the request
+   */
+  async postV2CommandsCompletionByHashRequestOpts(requestParameters) {
+    if (requestParameters["getCompletionByHashRequest"] == null) {
+      throw new RequiredError("getCompletionByHashRequest", 'Required parameter "getCompletionByHashRequest" was null or undefined when calling postV2CommandsCompletionByHash().');
+    }
+    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/completion-by-hash`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetCompletionByHashRequestToJSON(requestParameters["getCompletionByHashRequest"])
+    };
+  }
+  /**
+   * Look up a completion by its transaction hash. This is only available for completions received after upgrading to Canton version 3.5. A COMPLETION_NOT_FOUND error will be raised if either of the following is true:  - there is no completion with this transaction hash, - the completion is not visible to the user, - the completion was populated before upgrading to Canton version 3.5, - respective completions are all pruned.
+   */
+  async postV2CommandsCompletionByHashRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsCompletionByHashRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetCompletionByHashResponseFromJSON(jsonValue));
+  }
+  /**
+   * Look up a completion by its transaction hash. This is only available for completions received after upgrading to Canton version 3.5. A COMPLETION_NOT_FOUND error will be raised if either of the following is true:  - there is no completion with this transaction hash, - the completion is not visible to the user, - the completion was populated before upgrading to Canton version 3.5, - respective completions are all pruned.
+   */
+  async postV2CommandsCompletionByHash(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsCompletionByHashRaw(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)  Deprecated: please use ``GetCompletions`` instead. Subscribe to command completion events. 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)  Deprecated: please use ``GetCompletions`` instead. Subscribe to command completion events. 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"])
+    };
+  }
+  /**
+   * Submits a single composite command and waits for its result. Propagates the gRPC error of failed submissions including Daml interpretation errors.
+   */
+  async postV2CommandsSubmitAndWaitRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => SubmitAndWaitResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submits a single composite command and waits for its result. Propagates the gRPC error of failed submissions including Daml interpretation errors.
+   */
+  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"])
+    };
+  }
+  /**
+   * Submits a single composite reassignment command, waits for its result, and returns the reassignment. Propagates the gRPC error of failed submission.
+   */
+  async postV2CommandsSubmitAndWaitForReassignmentRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitForReassignmentRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsSubmitAndWaitForReassignmentResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submits a single composite reassignment command, waits for its result, and returns the reassignment. Propagates the gRPC error of failed submission.
+   */
+  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"])
+    };
+  }
+  /**
+   * Submits a single composite command, waits for its result, and returns the transaction. Propagates the gRPC error of failed submissions including Daml interpretation errors.
+   */
+  async postV2CommandsSubmitAndWaitForTransactionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2CommandsSubmitAndWaitForTransactionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsSubmitAndWaitForTransactionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Submits a single composite command, waits for its result, and returns the transaction. Propagates the gRPC error of failed submissions including Daml interpretation errors.
+   */
+  async postV2CommandsSubmitAndWaitForTransaction(requestParameters, initOverrides) {
+    const response = await this.postV2CommandsSubmitAndWaitForTransactionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2ContractsContractById without sending the request
+   */
+  async postV2ContractsContractByIdRequestOpts(requestParameters) {
+    if (requestParameters["getContractRequest"] == null) {
+      throw new RequiredError("getContractRequest", 'Required parameter "getContractRequest" was null or undefined when calling postV2ContractsContractById().');
+    }
+    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/contracts/contract-by-id`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetContractRequestToJSON(requestParameters["getContractRequest"])
+    };
+  }
+  /**
+   * Looking up contract data by contract ID. This endpoint is experimental / alpha, therefore no backwards compatibility is guaranteed. This endpoint must not be used to look up contracts which entered the participant via party replication or repair service.
+   */
+  async postV2ContractsContractByIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2ContractsContractByIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetContractResponseFromJSON(jsonValue));
+  }
+  /**
+   * Looking up contract data by contract ID. This endpoint is experimental / alpha, therefore no backwards compatibility is guaranteed. This endpoint must not be used to look up contracts which entered the participant via party replication or repair service.
+   */
+  async postV2ContractsContractById(requestParameters, initOverrides) {
+    const response = await this.postV2ContractsContractByIdRaw(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 the DAR and checks the upgrade compatibility of the DAR\'s packages with the set of the already vetted packages on the target vetting synchronizer. See ValidateDarFileRequest for details regarding the target vetting synchronizer.  The operation has no effect on the state of the participant or the Canton ledger: the DAR payload and its packages are not persisted neither are the packages vetted.
+   */
+  async postV2DarsValidateRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2DarsValidateRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Validates the DAR and checks the upgrade compatibility of the DAR\'s packages with the set of the already vetted packages on the target vetting synchronizer. See ValidateDarFileRequest for details regarding the target vetting synchronizer.  The operation has no effect on the state of the participant or the Canton ledger: the DAR payload and its packages are not persisted neither are the packages vetted.
+   */
+  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 the create and the consuming exercise event for the contract with the provided ID. No events will be returned for contracts that have been pruned because they have already been archived before the latest pruning offset. If the contract cannot be found for the request, or all the contract-events are filtered, a CONTRACT_EVENTS_NOT_FOUND error will be raised.
+   */
+  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 the create and the consuming exercise event for the contract with the provided ID. No events will be returned for contracts that have been pruned because they have already been archived before the latest pruning offset. If the contract cannot be found for the request, or all the contract-events are filtered, a CONTRACT_EVENTS_NOT_FOUND error will be raised.
+   */
+  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 a new identity provider configuration. The request will fail if the maximum allowed number of separate configurations is reached.
+   */
+  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 a new identity provider configuration. The request will fail if the maximum allowed number of separate configurations is reached.
+   */
+  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 prepared submission _asynchronously_ on the ledger. Requires `actAs` or `executeAs` scope for the submitting party when LAPI User authorization is enabled Requires a signature of the transaction from the submitting external party.
+   */
+  async postV2InteractiveSubmissionExecuteRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionExecuteRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Execute a prepared submission _asynchronously_ on the ledger. Requires `actAs` or `executeAs` scope for the submitting party when LAPI User authorization is enabled Requires a signature of the transaction from the submitting external party.
+   */
+  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"])
+    };
+  }
+  /**
+   * Similar to ExecuteSubmission but _synchronously_ wait for the completion of the transaction
+   */
+  async postV2InteractiveSubmissionExecuteandwaitRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionExecuteandwaitRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ExecuteSubmissionAndWaitResponseFromJSON(jsonValue));
+  }
+  /**
+   * Similar to ExecuteSubmission but _synchronously_ wait for the completion of the transaction
+   */
+  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"])
+    };
+  }
+  /**
+   * Similar to ExecuteSubmissionAndWait but additionally returns the transaction
+   */
+  async postV2InteractiveSubmissionExecuteandwaitfortransactionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionExecuteandwaitfortransactionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsExecuteSubmissionAndWaitForTransactionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Similar to ExecuteSubmissionAndWait but additionally returns the transaction
+   */
+  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"])
+    };
+  }
+  /**
+   * Compute the preferred packages for the vetting requirements in the request. A preferred package is the highest-versioned package for a provided package-name that is vetted by all the participants hosting the provided parties.  Ledger API clients should use this endpoint for constructing command submissions that are compatible with the provided preferred packages, by making informed decisions on: - which are the compatible packages that can be used to create contracts - which contract or exercise choice argument version can be used in the command - which choices can be executed on a template or interface of a contract  If the package preferences could not be computed due to no selection satisfying the requirements, a `FAILED_PRECONDITION` error will be returned.  Can be accessed by any Ledger API client with a valid token when Ledger API authorization is enabled.
+   */
+  async postV2InteractiveSubmissionPreferredPackagesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionPreferredPackagesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GetPreferredPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Compute the preferred packages for the vetting requirements in the request. A preferred package is the highest-versioned package for a provided package-name that is vetted by all the participants hosting the provided parties.  Ledger API clients should use this endpoint for constructing command submissions that are compatible with the provided preferred packages, by making informed decisions on: - which are the compatible packages that can be used to create contracts - which contract or exercise choice argument version can be used in the command - which choices can be executed on a template or interface of a contract  If the package preferences could not be computed due to no selection satisfying the requirements, a `FAILED_PRECONDITION` error will be returned.  Can be accessed by any Ledger API client with a valid token when Ledger API authorization is enabled.
+   */
+  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"])
+    };
+  }
+  /**
+   * Requires `readAs` scope for the submitting party when LAPI User authorization is enabled
+   */
+  async postV2InteractiveSubmissionPrepareRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2InteractiveSubmissionPrepareRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsPrepareSubmissionResponseFromJSON(jsonValue));
+  }
+  /**
+   * Requires `readAs` scope for the submitting party when LAPI User authorization is enabled
+   */
+  async postV2InteractiveSubmissionPrepare(requestParameters, initOverrides) {
+    const response = await this.postV2InteractiveSubmissionPrepareRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2PackageVettingList without sending the request
+   */
+  async postV2PackageVettingListRequestOpts(requestParameters) {
+    if (requestParameters["listVettedPackagesRequest"] == null) {
+      throw new RequiredError("listVettedPackagesRequest", 'Required parameter "listVettedPackagesRequest" was null or undefined when calling postV2PackageVettingList().');
+    }
+    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/list`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: ListVettedPackagesRequestToJSON(requestParameters["listVettedPackagesRequest"])
+    };
+  }
+  /**
+   * Lists which participant node vetted what packages on which synchronizer. Can be called by any authenticated user.
+   */
+  async postV2PackageVettingListRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PackageVettingListRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ListVettedPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Lists which participant node vetted what packages on which synchronizer. Can be called by any authenticated user.
+   */
+  async postV2PackageVettingList(requestParameters, initOverrides) {
+    const response = await this.postV2PackageVettingListRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2PackageVettingUpdate without sending the request
+   */
+  async postV2PackageVettingUpdateRequestOpts(requestParameters) {
+    if (requestParameters["updateVettedPackagesRequest"] == null) {
+      throw new RequiredError("updateVettedPackagesRequest", 'Required parameter "updateVettedPackagesRequest" was null or undefined when calling postV2PackageVettingUpdate().');
+    }
+    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/update`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateVettedPackagesRequestToJSON(requestParameters["updateVettedPackagesRequest"])
+    };
+  }
+  /**
+   * Update the vetted packages of this participant
+   */
+  async postV2PackageVettingUpdateRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PackageVettingUpdateRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdateVettedPackagesResponseFromJSON(jsonValue));
+  }
+  /**
+   * Update the vetted packages of this participant
+   */
+  async postV2PackageVettingUpdate(requestParameters, initOverrides) {
+    const response = await this.postV2PackageVettingUpdateRaw(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"]
+    };
+  }
+  /**
+   * Behaves the same as /dars. This endpoint will be deprecated and removed in a future release. Upload a DAR file to the participant.  If vetting is enabled in the request, the DAR is checked for upgrade compatibility with the set of the already vetted packages on the target vetting synchronizer See UploadDarFileRequest for details regarding vetting and the target vetting synchronizer.
+   */
+  async postV2PackagesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PackagesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response);
+  }
+  /**
+   * Behaves the same as /dars. This endpoint will be deprecated and removed in a future release. Upload a DAR file to the participant.  If vetting is enabled in the request, the DAR is checked for upgrade compatibility with the set of the already vetted packages on the target vetting synchronizer See UploadDarFileRequest for details regarding vetting and the target vetting synchronizer.
+   */
+  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"])
+    };
+  }
+  /**
+   * Allocates a new party on a ledger and adds it to the set managed by the participant. Caller specifies a party identifier suggestion, the actual identifier allocated might be different and is implementation specific. Caller can specify party metadata that is stored locally on the participant. This call may:  - Succeed, in which case the actual allocated identifier is visible in   the response. - Respond with a gRPC error  daml-on-kv-ledger: suggestion\'s uniqueness is checked by the validators in the consensus layer and call rejected if the identifier is already present. canton: completely different globally unique identifier is allocated. Behind the scenes calls to an internal protocol are made. As that protocol is richer than the surface protocol, the arguments take implicit values The party identifier suggestion must be a valid party name. Party names are required to be non-empty US-ASCII strings built from letters, digits, space, colon, minus and underscore limited to 255 chars
+   */
+  async postV2PartiesRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PartiesRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => AllocatePartyResponseFromJSON(jsonValue));
+  }
+  /**
+   * Allocates a new party on a ledger and adds it to the set managed by the participant. Caller specifies a party identifier suggestion, the actual identifier allocated might be different and is implementation specific. Caller can specify party metadata that is stored locally on the participant. This call may:  - Succeed, in which case the actual allocated identifier is visible in   the response. - Respond with a gRPC error  daml-on-kv-ledger: suggestion\'s uniqueness is checked by the validators in the consensus layer and call rejected if the identifier is already present. canton: completely different globally unique identifier is allocated. Behind the scenes calls to an internal protocol are made. As that protocol is richer than the surface protocol, the arguments take implicit values The party identifier suggestion must be a valid party name. Party names are required to be non-empty US-ASCII strings built from letters, digits, space, colon, minus and underscore limited to 255 chars
+   */
+  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"])
+    };
+  }
+  /**
+   * Alpha 3.3: Endpoint to allocate a new external party on a synchronizer  Expected to be stable in 3.5  The external party must be hosted (at least) on this node with either confirmation or observation permissions It can optionally be hosted on other nodes (then called a multi-hosted party). If hosted on additional nodes, explicit authorization of the hosting relationship must be performed on those nodes before the party can be used. Decentralized namespaces are supported but must be provided fully authorized by their owners. The individual owner namespace transactions can be submitted in the same call (fully authorized as well). In the simple case of a non-multi hosted, non-decentralized party, the RPC will return once the party is effectively allocated and ready to use, similarly to the AllocateParty behavior. For more complex scenarios applications may need to query the party status explicitly (only through the admin API as of now).
+   */
+  async postV2PartiesExternalAllocateRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PartiesExternalAllocateRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => AllocateExternalPartyResponseFromJSON(jsonValue));
+  }
+  /**
+   * Alpha 3.3: Endpoint to allocate a new external party on a synchronizer  Expected to be stable in 3.5  The external party must be hosted (at least) on this node with either confirmation or observation permissions It can optionally be hosted on other nodes (then called a multi-hosted party). If hosted on additional nodes, explicit authorization of the hosting relationship must be performed on those nodes before the party can be used. Decentralized namespaces are supported but must be provided fully authorized by their owners. The individual owner namespace transactions can be submitted in the same call (fully authorized as well). In the simple case of a non-multi hosted, non-decentralized party, the RPC will return once the party is effectively allocated and ready to use, similarly to the AllocateParty behavior. For more complex scenarios applications may need to query the party status explicitly (only through the admin API as of now).
+   */
+  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"])
+    };
+  }
+  /**
+   * Alpha 3.3: Convenience endpoint to generate topology transactions for external signing  Expected to be stable in 3.5  You may use this endpoint to generate the common external topology transactions which can be signed externally and uploaded as part of the allocate party process  Note that this request will create a normal namespace using the same key for the identity as for signing. More elaborate schemes such as multi-signature or decentralized parties require you to construct the topology transactions yourself.
+   */
+  async postV2PartiesExternalGenerateTopologyRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2PartiesExternalGenerateTopologyRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => GenerateExternalPartyTopologyResponseFromJSON(jsonValue));
+  }
+  /**
+   * Alpha 3.3: Convenience endpoint to generate topology transactions for external signing  Expected to be stable in 3.5  You may use this endpoint to generate the common external topology transactions which can be signed externally and uploaded as part of the allocate party process  Note that this request will create a normal namespace using the same key for the identity as for signing. More elaborate schemes such as multi-signature or decentralized parties require you to construct the topology transactions yourself.
+   */
+  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.  Returns a stream of the snapshot of the active contracts and incomplete (un)assignments at a ledger offset. Once the stream of GetActiveContractsResponses completes, the client SHOULD begin streaming updates from the update service, starting at the GetActiveContractsRequest.active_at_offset specified in this request. Clients SHOULD NOT assume that the set of active contracts they receive reflects the state at the ledger end. If the given offset is different than the ledger end, and there are (un)assignments in-flight at the given offset, the snapshot may fail with \"FAILED_PRECONDITION/PARTICIPANT_PRUNED_DATA_ACCESSED\". Note that it is ok to request acs snapshots for party migration with offsets other than ledger end, because party migration is not concerned with incomplete (un)assignments.  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.  Returns a stream of the snapshot of the active contracts and incomplete (un)assignments at a ledger offset. Once the stream of GetActiveContractsResponses completes, the client SHOULD begin streaming updates from the update service, starting at the GetActiveContractsRequest.active_at_offset specified in this request. Clients SHOULD NOT assume that the set of active contracts they receive reflects the state at the ledger end. If the given offset is different than the ledger end, and there are (un)assignments in-flight at the given offset, the snapshot may fail with \"FAILED_PRECONDITION/PARTICIPANT_PRUNED_DATA_ACCESSED\". Note that it is ok to request acs snapshots for party migration with offsets other than ledger end, because party migration is not concerned with incomplete (un)assignments.  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 postV2StateActiveContractsPage without sending the request
+   */
+  async postV2StateActiveContractsPageRequestOpts(requestParameters) {
+    if (requestParameters["getActiveContractsPageRequest"] == null) {
+      throw new RequiredError("getActiveContractsPageRequest", 'Required parameter "getActiveContractsPageRequest" was null or undefined when calling postV2StateActiveContractsPage().');
+    }
+    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/state/active-contracts-page`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetActiveContractsPageRequestToJSON(requestParameters["getActiveContractsPageRequest"])
+    };
+  }
+  /**
+   * Returns a page of the snapshot of the active contracts and incomplete (un)assignments at a ledger offset. Once all pages are fetched by repeated calls to ``GetActiveContractsPage``, the client SHOULD begin retrieving updates from the update service, starting at the ``GetActiveContractsPageResponse``.``active_at_offset`` specified in this request. Clients SHOULD NOT assume that the set of active contracts they receive reflects the state at the ledger end.
+   */
+  async postV2StateActiveContractsPageRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2StateActiveContractsPageRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetActiveContractsPageResponseFromJSON(jsonValue));
+  }
+  /**
+   * Returns a page of the snapshot of the active contracts and incomplete (un)assignments at a ledger offset. Once all pages are fetched by repeated calls to ``GetActiveContractsPage``, the client SHOULD begin retrieving updates from the update service, starting at the ``GetActiveContractsPageResponse``.``active_at_offset`` specified in this request. Clients SHOULD NOT assume that the set of active contracts they receive reflects the state at the ledger end.
+   */
+  async postV2StateActiveContractsPage(requestParameters, initOverrides) {
+    const response = await this.postV2StateActiveContractsPageRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2TrafficAccounts without sending the request
+   */
+  async postV2TrafficAccountsRequestOpts(requestParameters) {
+    if (requestParameters["updateAccountRequest"] == null) {
+      throw new RequiredError("updateAccountRequest", 'Required parameter "updateAccountRequest" was null or undefined when calling postV2TrafficAccounts().');
+    }
+    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/traffic/accounts`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateAccountRequestToJSON(requestParameters["updateAccountRequest"])
+    };
+  }
+  /**
+   * Update account state for a given account ID. Permissioned only to Ledger API admin users.  NOTE: This endpoint is exposed only when traffic enforcement feature is enabled (canton.participants.participant1.traffic-enforcement.enabled = true)
+   */
+  async postV2TrafficAccountsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2TrafficAccountsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => UpdateAccountResponseFromJSON(jsonValue));
+  }
+  /**
+   * Update account state for a given account ID. Permissioned only to Ledger API admin users.  NOTE: This endpoint is exposed only when traffic enforcement feature is enabled (canton.participants.participant1.traffic-enforcement.enabled = true)
+   */
+  async postV2TrafficAccounts(requestParameters, initOverrides) {
+    const response = await this.postV2TrafficAccountsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2TrafficEventsPrune without sending the request
+   */
+  async postV2TrafficEventsPruneRequestOpts(requestParameters) {
+    if (requestParameters["pruneEventsRequest"] == null) {
+      throw new RequiredError("pruneEventsRequest", 'Required parameter "pruneEventsRequest" was null or undefined when calling postV2TrafficEventsPrune().');
+    }
+    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/traffic/events/prune`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: PruneEventsRequestToJSON(requestParameters["pruneEventsRequest"])
+    };
+  }
+  /**
+   * Prune events from the event log that are older than a given timestamp. Permissioned only to Ledger API admin users. WARNING: Affects de-duplication. If an event is pruned, de-duplication UpdateAccount requests on it will NOT be possible.  NOTE: This endpoint is exposed only when traffic enforcement feature is enabled (canton.participants.participant1.traffic-enforcement.enabled = true)
+   */
+  async postV2TrafficEventsPruneRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2TrafficEventsPruneRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PruneEventsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Prune events from the event log that are older than a given timestamp. Permissioned only to Ledger API admin users. WARNING: Affects de-duplication. If an event is pruned, de-duplication UpdateAccount requests on it will NOT be possible.  NOTE: This endpoint is exposed only when traffic enforcement feature is enabled (canton.participants.participant1.traffic-enforcement.enabled = true)
+   */
+  async postV2TrafficEventsPrune(requestParameters, initOverrides) {
+    const response = await this.postV2TrafficEventsPruneRaw(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"])
+    };
+  }
+  /**
+   * Read the ledger\'s filtered update stream for the specified contents and filters. It returns the event types in accordance with the stream contents selected. Also the selection criteria for individual events depends on the transaction shape chosen.  - ACS delta: a requesting party must be a stakeholder of an event for it to be included. - ledger effects: a requesting party must be a witness of an event for it to be included. 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));
+  }
+  /**
+   * Read the ledger\'s filtered update stream for the specified contents and filters. It returns the event types in accordance with the stream contents selected. Also the selection criteria for individual events depends on the transaction shape chosen.  - ACS delta: a requesting party must be a stakeholder of an event for it to be included. - ledger effects: a requesting party must be a witness of an event for it to be included. 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 postV2UpdatesGetUpdatesPage without sending the request
+   */
+  async postV2UpdatesGetUpdatesPageRequestOpts(requestParameters) {
+    if (requestParameters["getUpdatesPageRequest"] == null) {
+      throw new RequiredError("getUpdatesPageRequest", 'Required parameter "getUpdatesPageRequest" was null or undefined when calling postV2UpdatesGetUpdatesPage().');
+    }
+    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/get-updates-page`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdatesPageRequestToJSON(requestParameters["getUpdatesPageRequest"])
+    };
+  }
+  /**
+   * Read a page of ledger\'s filtered updates. It returns the event types in accordance with the specified contents and filters. Additionally, the selection criteria for individual events depends on the transaction shape chosen.  - ACS delta: an event is included only if the requesting party is a stakeholder. - ledger effects: an event is included if the requesting party is a witness.
+   */
+  async postV2UpdatesGetUpdatesPageRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesGetUpdatesPageRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetUpdatesPageResponseFromJSON(jsonValue));
+  }
+  /**
+   * Read a page of ledger\'s filtered updates. It returns the event types in accordance with the specified contents and filters. Additionally, the selection criteria for individual events depends on the transaction shape chosen.  - ACS delta: an event is included only if the requesting party is a stakeholder. - ledger effects: an event is included if the requesting party is a witness.
+   */
+  async postV2UpdatesGetUpdatesPage(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesGetUpdatesPageRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for postV2UpdatesUpdateByHash without sending the request
+   */
+  async postV2UpdatesUpdateByHashRequestOpts(requestParameters) {
+    if (requestParameters["getUpdateByHashRequest"] == null) {
+      throw new RequiredError("getUpdateByHashRequest", 'Required parameter "getUpdateByHashRequest" was null or undefined when calling postV2UpdatesUpdateByHash().');
+    }
+    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-hash`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: GetUpdateByHashRequestToJSON(requestParameters["getUpdateByHashRequest"])
+    };
+  }
+  /**
+   * Look up an update by its transaction hash. This is only available for updates received after upgrading to Canton version 3.6. If there is no update with this transaction hash, or all the events are filtered, or the update was populated before upgrading to Canton version 3.6, an UPDATE_NOT_FOUND error will be raised.
+   */
+  async postV2UpdatesUpdateByHashRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesUpdateByHashRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetUpdateResponseFromJSON(jsonValue));
+  }
+  /**
+   * Look up an update by its transaction hash. This is only available for updates received after upgrading to Canton version 3.6. If there is no update with this transaction hash, or all the events are filtered, or the update was populated before upgrading to Canton version 3.6, an UPDATE_NOT_FOUND error will be raised.
+   */
+  async postV2UpdatesUpdateByHash(requestParameters, initOverrides) {
+    const response = await this.postV2UpdatesUpdateByHashRaw(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"])
+    };
+  }
+  /**
+   * Lookup an update by its ID. If there is no update with this ID, or all the events are filtered, an UPDATE_NOT_FOUND error will be raised.
+   */
+  async postV2UpdatesUpdateByIdRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesUpdateByIdRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetUpdateResponseFromJSON(jsonValue));
+  }
+  /**
+   * Lookup an update by its ID. If there is no update with this ID, or all the events are filtered, an UPDATE_NOT_FOUND error will be raised.
+   */
+  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"])
+    };
+  }
+  /**
+   * Lookup an update by its offset. If there is no update with this offset, or all the events are filtered, an UPDATE_NOT_FOUND error will be raised.
+   */
+  async postV2UpdatesUpdateByOffsetRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.postV2UpdatesUpdateByOffsetRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => JsGetUpdateResponseFromJSON(jsonValue));
+  }
+  /**
+   * Lookup an update by its offset. If there is no update with this offset, or all the events are filtered, an UPDATE_NOT_FOUND error will be raised.
+   */
+  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 a new 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 a new 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 rights to a user. Granting rights does not affect the resource version of the corresponding user.
+   */
+  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 rights to a user. Granting rights does not affect the resource version of the corresponding user.
+   */
+  async postV2UsersUserIdRights(requestParameters, initOverrides) {
+    const response = await this.postV2UsersUserIdRightsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+export { DefaultApi };
+//# sourceMappingURL=DYK7UQLE.js.map
+//# sourceMappingURL=DYK7UQLE.js.map