var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import { PartyManagementService } from "./party_management_service.js";
import { stackIntercept } from "@protobuf-ts/runtime-rpc";
class PartyManagementServiceClient {
  constructor(_transport) {
    this._transport = _transport;
    __publicField(this, "typeName", PartyManagementService.typeName);
    __publicField(this, "methods", PartyManagementService.methods);
    __publicField(this, "options", PartyManagementService.options);
  }
  /**
   * 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
   *
   * @generated from protobuf rpc: GetParticipantId
   */
  getParticipantId(input, options) {
    const method = this.methods[0], opt = this._transport.mergeOptions(options);
    return stackIntercept("unary", this._transport, method, opt, input);
  }
  /**
   * Get the party details of the given parties. Only known parties will be
   * returned in the list.
   *
   * @generated from protobuf rpc: GetParties
   */
  getParties(input, options) {
    const method = this.methods[1], opt = this._transport.mergeOptions(options);
    return stackIntercept(
      "unary",
      this._transport,
      method,
      opt,
      input
    );
  }
  /**
   * 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.
   *
   * @generated from protobuf rpc: ListKnownParties
   */
  listKnownParties(input, options) {
    const method = this.methods[2], opt = this._transport.mergeOptions(options);
    return stackIntercept("unary", this._transport, method, opt, input);
  }
  /**
   * 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
   *
   * @generated from protobuf rpc: AllocateParty
   */
  allocateParty(input, options) {
    const method = this.methods[3], opt = this._transport.mergeOptions(options);
    return stackIntercept(
      "unary",
      this._transport,
      method,
      opt,
      input
    );
  }
  /**
   * 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).
   *
   * @generated from protobuf rpc: AllocateExternalParty
   */
  allocateExternalParty(input, options) {
    const method = this.methods[4], opt = this._transport.mergeOptions(options);
    return stackIntercept("unary", this._transport, method, opt, input);
  }
  /**
   * Update selected modifiable participant-local attributes of a party details resource.
   * Can update the participant's local information for local parties.
   *
   * @generated from protobuf rpc: UpdatePartyDetails
   */
  updatePartyDetails(input, options) {
    const method = this.methods[5], opt = this._transport.mergeOptions(options);
    return stackIntercept("unary", this._transport, method, opt, input);
  }
  /**
   * Update the assignment of a party from one IDP to another.
   *
   * @generated from protobuf rpc: UpdatePartyIdentityProviderId
   */
  updatePartyIdentityProviderId(input, options) {
    const method = this.methods[6], opt = this._transport.mergeOptions(options);
    return stackIntercept("unary", this._transport, method, opt, input);
  }
  /**
   * 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.
   *
   * @generated from protobuf rpc: GenerateExternalPartyTopology
   */
  generateExternalPartyTopology(input, options) {
    const method = this.methods[7], opt = this._transport.mergeOptions(options);
    return stackIntercept("unary", this._transport, method, opt, input);
  }
}
export {
  PartyManagementServiceClient
};
//# sourceMappingURL=party_management_service.client.js.map