admin

type AllocateExternalPartyRequest struct {

	// TODO(#27670) support synchronizer aliases
	// Synchronizer ID on which to onboard the party
	// Required
	Synchronizer string `protobuf:"bytes,1,opt,name=synchronizer,proto3" json:"synchronizer,omitempty"`
	// TopologyTransactions to onboard the external party
	// Can contain:
	// - A namespace for the party.
	// This can be either a single NamespaceDelegation,
	// or DecentralizedNamespaceDefinition along with its authorized namespace owners in the form of NamespaceDelegations.
	// May be provided, if so it must be fully authorized by the signatures in this request combined with the existing topology state.
	// - A PartyToKeyMapping to register the party's signing keys.
	// May be provided, if so it must be fully authorized by the signatures in this request combined with the existing topology state.
	// - A PartyToParticipant to register the hosting relationship of the party.
	// Must be provided.
	// Required
	OnboardingTransactions []*AllocateExternalPartyRequest_SignedTransaction `` /* 127-byte string literal not displayed */
	// Optional signatures of the combined hash of all onboarding_transactions
	// This may be used instead of providing signatures on each individual transaction
	MultiHashSignatures []*v2.Signature `protobuf:"bytes,3,rep,name=multi_hash_signatures,json=multiHashSignatures,proto3" json:"multi_hash_signatures,omitempty"`
	// The id of the “Identity Provider“
	// If not set, assume the party is managed by the default identity provider.
	// Optional
	IdentityProviderId string `protobuf:"bytes,4,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type AllocateExternalPartyRequest_SignedTransaction struct {

	// The serialized TopologyTransaction
	Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// Additional signatures for this transaction specifically
	// Use for transactions that require additional signatures beyond the namespace key signatures
	// e.g: PartyToKeyMapping must be signed by all registered keys
	Signatures []*v2.Signature `protobuf:"bytes,2,rep,name=signatures,proto3" json:"signatures,omitempty"`
	// contains filtered or unexported fields
}

type AllocateExternalPartyResponse struct {
	PartyId string `protobuf:"bytes,1,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// contains filtered or unexported fields
}

type AllocatePartyRequest struct {

	// A hint to the participant which party ID to allocate. It can be
	// ignored.
	// Must be a valid PartyIdString (as described in “value.proto“).
	// Optional
	PartyIdHint string `protobuf:"bytes,1,opt,name=party_id_hint,json=partyIdHint,proto3" json:"party_id_hint,omitempty"`
	// Participant-local metadata to be stored in the “PartyDetails“ of this newly allocated party.
	// Optional
	LocalMetadata *ObjectMeta `protobuf:"bytes,3,opt,name=local_metadata,json=localMetadata,proto3" json:"local_metadata,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the party is managed by the default identity provider or party is not hosted by the participant.
	IdentityProviderId string `protobuf:"bytes,4,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// The synchronizer, on which the party should be allocated.
	// For backwards compatibility, this field may be omitted, if the participant is connected to only one synchronizer.
	// Otherwise a synchronizer must be specified.
	// Optional
	SynchronizerId string `protobuf:"bytes,5,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// The user who will get the act_as rights to the newly allocated party.
	// If set to an empty string (the default), no user will get rights to the party.
	// Optional
	UserId string `protobuf:"bytes,6,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// contains filtered or unexported fields
}

type AllocatePartyResponse struct {
	PartyDetails *PartyDetails `protobuf:"bytes,1,opt,name=party_details,json=partyDetails,proto3" json:"party_details,omitempty"`
	// contains filtered or unexported fields
}

type CommandInspectionServiceClient interface {
	// Inquire about the status of a command.
	// This service is used for debugging only. The command status is only tracked in memory and is not persisted.
	// The service can be used to understand the failure status and the structure of a command.
	// Requires admin privileges
	// The service is alpha without backward compatibility guarantees.
	GetCommandStatus(ctx context.Context, in *GetCommandStatusRequest, opts ...grpc.CallOption) (*GetCommandStatusResponse, error)
}

type CommandInspectionServiceServer interface {
	// Inquire about the status of a command.
	// This service is used for debugging only. The command status is only tracked in memory and is not persisted.
	// The service can be used to understand the failure status and the structure of a command.
	// Requires admin privileges
	// The service is alpha without backward compatibility guarantees.
	GetCommandStatus(context.Context, *GetCommandStatusRequest) (*GetCommandStatusResponse, error)
	// contains filtered or unexported methods
}

type CommandState int32

type CommandStatus struct {
	Started           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=started,proto3" json:"started,omitempty"`
	Completed         *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=completed,proto3" json:"completed,omitempty"`
	Completion        *v2.Completion         `protobuf:"bytes,3,opt,name=completion,proto3" json:"completion,omitempty"`
	State             CommandState           `protobuf:"varint,4,opt,name=state,proto3,enum=com.daml.ledger.api.v2.admin.CommandState" json:"state,omitempty"`
	Commands          []*v2.Command          `protobuf:"bytes,5,rep,name=commands,proto3" json:"commands,omitempty"`
	RequestStatistics *RequestStatistics     `protobuf:"bytes,6,opt,name=request_statistics,json=requestStatistics,proto3" json:"request_statistics,omitempty"`
	Updates           *CommandUpdates        `protobuf:"bytes,7,opt,name=updates,proto3" json:"updates,omitempty"`
	// contains filtered or unexported fields
}

type CommandUpdates struct {
	Created       []*Contract `protobuf:"bytes,1,rep,name=created,proto3" json:"created,omitempty"`
	Archived      []*Contract `protobuf:"bytes,2,rep,name=archived,proto3" json:"archived,omitempty"`
	Exercised     uint32      `protobuf:"varint,3,opt,name=exercised,proto3" json:"exercised,omitempty"`
	Fetched       uint32      `protobuf:"varint,4,opt,name=fetched,proto3" json:"fetched,omitempty"`
	LookedUpByKey uint32      `protobuf:"varint,5,opt,name=looked_up_by_key,json=lookedUpByKey,proto3" json:"looked_up_by_key,omitempty"`
	// contains filtered or unexported fields
}

type Contract struct {

	// The identifier of the template used to create the contract.
	// The identifier uses the package-id reference format.
	//
	// Required
	TemplateId *v2.Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The contract's ID
	//
	// Required
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The contract key, if defined
	//
	// Optional
	ContractKey *v2.Value `protobuf:"bytes,3,opt,name=contract_key,json=contractKey,proto3" json:"contract_key,omitempty"`
	// contains filtered or unexported fields
}

type CreateIdentityProviderConfigRequest struct {

	// Required
	IdentityProviderConfig *IdentityProviderConfig `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CreateIdentityProviderConfigResponse struct {
	IdentityProviderConfig *IdentityProviderConfig `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CreateUserRequest struct {

	// The user to create.
	// Required
	User *User `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// The rights to be assigned to the user upon creation,
	// which SHOULD include appropriate rights for the “user.primary_party“.
	// Optional
	Rights []*Right `protobuf:"bytes,2,rep,name=rights,proto3" json:"rights,omitempty"`
	// contains filtered or unexported fields
}

type CreateUserResponse struct {

	// Created user.
	User *User `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// contains filtered or unexported fields
}

type DeleteIdentityProviderConfigRequest struct {

	// The identity provider config to delete.
	// Required
	IdentityProviderId string `protobuf:"bytes,1,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type DeleteIdentityProviderConfigResponse struct {
	// contains filtered or unexported fields
}

type DeleteUserRequest struct {

	// The user to delete.
	// Required
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the user is managed by the default identity provider.
	IdentityProviderId string `protobuf:"bytes,2,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type DeleteUserResponse struct {
	// contains filtered or unexported fields
}

type GenerateExternalPartyTopologyRequest struct {

	// TODO(#27670) support synchronizer aliases
	// Required: synchronizer-id for which we are building this request.
	Synchronizer string `protobuf:"bytes,1,opt,name=synchronizer,proto3" json:"synchronizer,omitempty"`
	// Required: the actual party id will be constructed from this hint and a fingerprint of the public key
	PartyHint string `protobuf:"bytes,2,opt,name=party_hint,json=partyHint,proto3" json:"party_hint,omitempty"`
	// Required: public key
	PublicKey *v2.SigningPublicKey `protobuf:"bytes,3,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// Optional: if true, then the local participant will only be observing, not confirming. Default false.
	LocalParticipantObservationOnly bool `` /* 159-byte string literal not displayed */
	// Optional: other participant ids which should be confirming for this party
	OtherConfirmingParticipantUids []string `` /* 155-byte string literal not displayed */
	// Optional: Confirmation threshold >= 1 for the party. Defaults to all available confirmers (or if set to 0).
	ConfirmationThreshold uint32 `protobuf:"varint,6,opt,name=confirmation_threshold,json=confirmationThreshold,proto3" json:"confirmation_threshold,omitempty"`
	// Optional: other observing participant ids for this party
	ObservingParticipantUids []string `` /* 135-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GenerateExternalPartyTopologyResponse struct {

	// the generated party id
	PartyId string `protobuf:"bytes,1,opt,name=party_id,json=partyId,proto3" json:"party_id,omitempty"`
	// the fingerprint of the supplied public key
	PublicKeyFingerprint string `protobuf:"bytes,2,opt,name=public_key_fingerprint,json=publicKeyFingerprint,proto3" json:"public_key_fingerprint,omitempty"`
	// The serialized topology transactions which need to be signed and submitted as part of the allocate party process
	// Note that the serialization includes the versioning information. Therefore, the transaction here is serialized
	// as an `UntypedVersionedMessage` which in turn contains the serialized `TopologyTransaction` in the version
	// supported by the synchronizer.
	TopologyTransactions [][]byte `protobuf:"bytes,3,rep,name=topology_transactions,json=topologyTransactions,proto3" json:"topology_transactions,omitempty"`
	// the multi-hash which may be signed instead of each individual transaction
	MultiHash []byte `protobuf:"bytes,4,opt,name=multi_hash,json=multiHash,proto3" json:"multi_hash,omitempty"`
	// contains filtered or unexported fields
}

type GetCommandStatusRequest struct {
	CommandIdPrefix string       `protobuf:"bytes,1,opt,name=command_id_prefix,json=commandIdPrefix,proto3" json:"command_id_prefix,omitempty"`    // optional filter by command id
	State           CommandState `protobuf:"varint,2,opt,name=state,proto3,enum=com.daml.ledger.api.v2.admin.CommandState" json:"state,omitempty"` // optional filter by state
	Limit           uint32       `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`                                                // optional limit of returned statuses, defaults to 100
	// contains filtered or unexported fields
}

type GetCommandStatusResponse struct {
	CommandStatus []*CommandStatus `protobuf:"bytes,1,rep,name=command_status,json=commandStatus,proto3" json:"command_status,omitempty"`
	// contains filtered or unexported fields
}

type GetIdentityProviderConfigRequest struct {

	// Required
	IdentityProviderId string `protobuf:"bytes,1,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type GetIdentityProviderConfigResponse struct {
	IdentityProviderConfig *IdentityProviderConfig `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GetParticipantIdRequest struct {
	// contains filtered or unexported fields
}

type GetParticipantIdResponse struct {

	// Identifier of the participant, which SHOULD be globally unique.
	// Must be a valid LedgerString (as describe in “value.proto“).
	ParticipantId string `protobuf:"bytes,1,opt,name=participant_id,json=participantId,proto3" json:"participant_id,omitempty"`
	// contains filtered or unexported fields
}

type GetPartiesRequest struct {

	// The stable, unique identifier of the Daml parties.
	// Must be valid PartyIdStrings (as described in “value.proto“).
	// Required
	Parties []string `protobuf:"bytes,1,rep,name=parties,proto3" json:"parties,omitempty"`
	// The id of the “Identity Provider“ whose parties should be retrieved.
	// Optional, if not set, assume the party is managed by the default identity provider or party is not hosted by the participant.
	IdentityProviderId string `protobuf:"bytes,2,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type GetPartiesResponse struct {

	// The details of the requested Daml parties by the participant, if known.
	// The party details may not be in the same order as requested.
	// Required
	PartyDetails []*PartyDetails `protobuf:"bytes,1,rep,name=party_details,json=partyDetails,proto3" json:"party_details,omitempty"`
	// contains filtered or unexported fields
}

type GetUserRequest struct {

	// The user whose data to retrieve.
	// If set to empty string (the default), then the data for the authenticated user will be retrieved.
	// Optional
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the user is managed by the default identity provider.
	IdentityProviderId string `protobuf:"bytes,2,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type GetUserResponse struct {

	// Retrieved user.
	User *User `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
	// contains filtered or unexported fields
}

type GrantUserRightsRequest struct {

	// The user to whom to grant rights.
	// Required
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The rights to grant.
	// Optional
	Rights []*Right `protobuf:"bytes,2,rep,name=rights,proto3" json:"rights,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the user is managed by the default identity provider.
	IdentityProviderId string `protobuf:"bytes,3,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type GrantUserRightsResponse struct {

	// The rights that were newly granted by the request.
	NewlyGrantedRights []*Right `protobuf:"bytes,1,rep,name=newly_granted_rights,json=newlyGrantedRights,proto3" json:"newly_granted_rights,omitempty"`
	// contains filtered or unexported fields
}

type IdentityProviderConfig struct {

	// The identity provider identifier
	// Must be a valid LedgerString (as describe in “value.proto“).
	// Required
	IdentityProviderId string `protobuf:"bytes,1,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// When set, the callers using JWT tokens issued by this identity provider are denied all access
	// to the Ledger API.
	// Optional,
	// Modifiable
	IsDeactivated bool `protobuf:"varint,2,opt,name=is_deactivated,json=isDeactivated,proto3" json:"is_deactivated,omitempty"`
	// Specifies the issuer of the JWT token.
	// The issuer value is a case sensitive URL using the https scheme that contains scheme, host,
	// and optionally, port number and path components and no query or fragment components.
	// Required
	// Modifiable
	Issuer string `protobuf:"bytes,3,opt,name=issuer,proto3" json:"issuer,omitempty"`
	// The JWKS (JSON Web Key Set) URL.
	// The Ledger API uses JWKs (JSON Web Keys) from the provided URL to verify that the JWT has been
	// signed with the loaded JWK. Only RS256 (RSA Signature with SHA-256) signing algorithm is supported.
	// Required
	// Modifiable
	JwksUrl string `protobuf:"bytes,4,opt,name=jwks_url,json=jwksUrl,proto3" json:"jwks_url,omitempty"`
	// Specifies the audience of the JWT token.
	// When set, the callers using JWT tokens issued by this identity provider are allowed to get an access
	// only if the "aud" claim includes the string specified here
	// Optional,
	// Modifiable
	Audience string `protobuf:"bytes,5,opt,name=audience,proto3" json:"audience,omitempty"`
	// contains filtered or unexported fields
}

type IdentityProviderConfigServiceClient interface {
	// Create a new identity provider configuration.
	// The request will fail if the maximum allowed number of separate configurations is reached.
	CreateIdentityProviderConfig(ctx context.Context, in *CreateIdentityProviderConfigRequest, opts ...grpc.CallOption) (*CreateIdentityProviderConfigResponse, error)
	// Get the identity provider configuration data by id.
	GetIdentityProviderConfig(ctx context.Context, in *GetIdentityProviderConfigRequest, opts ...grpc.CallOption) (*GetIdentityProviderConfigResponse, error)
	// Update selected modifiable attribute of an identity provider config resource described
	// by the “IdentityProviderConfig“ message.
	UpdateIdentityProviderConfig(ctx context.Context, in *UpdateIdentityProviderConfigRequest, opts ...grpc.CallOption) (*UpdateIdentityProviderConfigResponse, error)
	// List all existing identity provider configurations.
	ListIdentityProviderConfigs(ctx context.Context, in *ListIdentityProviderConfigsRequest, opts ...grpc.CallOption) (*ListIdentityProviderConfigsResponse, error)
	// Delete an existing identity provider configuration.
	DeleteIdentityProviderConfig(ctx context.Context, in *DeleteIdentityProviderConfigRequest, opts ...grpc.CallOption) (*DeleteIdentityProviderConfigResponse, error)
}

type IdentityProviderConfigServiceServer interface {
	// Create a new identity provider configuration.
	// The request will fail if the maximum allowed number of separate configurations is reached.
	CreateIdentityProviderConfig(context.Context, *CreateIdentityProviderConfigRequest) (*CreateIdentityProviderConfigResponse, error)
	// Get the identity provider configuration data by id.
	GetIdentityProviderConfig(context.Context, *GetIdentityProviderConfigRequest) (*GetIdentityProviderConfigResponse, error)
	// Update selected modifiable attribute of an identity provider config resource described
	// by the “IdentityProviderConfig“ message.
	UpdateIdentityProviderConfig(context.Context, *UpdateIdentityProviderConfigRequest) (*UpdateIdentityProviderConfigResponse, error)
	// List all existing identity provider configurations.
	ListIdentityProviderConfigs(context.Context, *ListIdentityProviderConfigsRequest) (*ListIdentityProviderConfigsResponse, error)
	// Delete an existing identity provider configuration.
	DeleteIdentityProviderConfig(context.Context, *DeleteIdentityProviderConfigRequest) (*DeleteIdentityProviderConfigResponse, error)
	// contains filtered or unexported methods
}

type ListIdentityProviderConfigsRequest struct {
	// contains filtered or unexported fields
}

type ListIdentityProviderConfigsResponse struct {
	IdentityProviderConfigs []*IdentityProviderConfig `` /* 132-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ListKnownPackagesRequest struct {
	// contains filtered or unexported fields
}

type ListKnownPackagesResponse struct {

	// The details of all Daml-LF packages known to backing participant.
	// Required
	PackageDetails []*PackageDetails `protobuf:"bytes,1,rep,name=package_details,json=packageDetails,proto3" json:"package_details,omitempty"`
	// contains filtered or unexported fields
}

type ListKnownPartiesRequest struct {

	// Pagination token to determine the specific page to fetch. Using the token guarantees that parties on a subsequent
	// page are all lexically greater than the last party on a previous page. Server does not store intermediate results
	// between calls chained by a series of page tokens. As a consequence, if new parties are being added and a page is
	// requested twice using the same token, more parties can be returned on the second call.
	// Leave empty to fetch the first page.
	// Optional
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// Maximum number of results to be returned by the server. The server will return no more than that many results,
	// but it might return fewer. If the page_size is 0, the server will decide the number of results to be returned.
	// If the page_size exceeds the maximum supported by the server, an error will be returned. To obtain the server's
	// maximum consult the PartyManagementFeature descriptor available in the VersionService.
	// Optional
	PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// The id of the “Identity Provider“ whose parties should be retrieved.
	// Optional, if not set, assume the party is managed by the default identity provider or party is not hosted by the participant.
	IdentityProviderId string `protobuf:"bytes,1,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type ListKnownPartiesResponse struct {

	// The details of all Daml parties known by the participant.
	// Required
	PartyDetails []*PartyDetails `protobuf:"bytes,1,rep,name=party_details,json=partyDetails,proto3" json:"party_details,omitempty"`
	// Pagination token to retrieve the next page.
	// Empty, if there are no further results.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

type ListUserRightsRequest struct {

	// The user for which to list the rights.
	// If set to empty string (the default), then the rights for the authenticated user will be listed.
	// Required
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the user is managed by the default identity provider.
	IdentityProviderId string `protobuf:"bytes,2,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type ListUserRightsResponse struct {

	// All rights of the user.
	Rights []*Right `protobuf:"bytes,1,rep,name=rights,proto3" json:"rights,omitempty"`
	// contains filtered or unexported fields
}

type ListUsersRequest struct {

	// Pagination token to determine the specific page to fetch.
	// Leave empty to fetch the first page.
	// Optional
	PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// Maximum number of results to be returned by the server. The server will return no more than that many results, but it might return fewer.
	// If 0, the server will decide the number of results to be returned.
	// Optional
	PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the user is managed by the default identity provider.
	IdentityProviderId string `protobuf:"bytes,4,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type ListUsersResponse struct {

	// A subset of users of the participant node that fit into this page.
	Users []*User `protobuf:"bytes,1,rep,name=users,proto3" json:"users,omitempty"`
	// Pagination token to retrieve the next page.
	// Empty, if there are no further results.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
	// contains filtered or unexported fields
}

type ObjectMeta struct {

	// An opaque, non-empty value, populated by a participant server which represents the internal version of the resource
	// this “ObjectMeta“ message is attached to. The participant server will change it to a unique value each time the corresponding resource is updated.
	// You must not rely on the format of resource version. The participant server might change it without notice.
	// You can obtain the newest resource version value by issuing a read request.
	// You may use it for concurrent change detection by passing it back unmodified in an update request.
	// The participant server will then compare the passed value with the value maintained by the system to determine
	// if any other updates took place since you had read the resource version.
	// Upon a successful update you are guaranteed that no other update took place during your read-modify-write sequence.
	// However, if another update took place during your read-modify-write sequence then your update will fail with an appropriate error.
	// Concurrent change control is optional. It will be applied only if you include a resource version in an update request.
	// When creating a new instance of a resource you must leave the resource version empty.
	// Its value will be populated by the participant server upon successful resource creation.
	// Optional
	ResourceVersion string `protobuf:"bytes,6,opt,name=resource_version,json=resourceVersion,proto3" json:"resource_version,omitempty"`
	// A set of modifiable key-value pairs that can be used to represent arbitrary, client-specific metadata.
	// Constraints:
	//
	// 1. The total size over all keys and values cannot exceed 256kb in UTF-8 encoding.
	// 2. Keys are composed of an optional prefix segment and a required name segment such that:
	//
	//   - key prefix, when present, must be a valid DNS subdomain with at most 253 characters, followed by a '/' (forward slash) character,
	//   - name segment must have at most 63 characters that are either alphanumeric ([a-z0-9A-Z]), or a '.' (dot), '-' (dash) or '_' (underscore);
	//     and it must start and end with an alphanumeric character.
	//
	// 3. Values can be any non-empty strings.
	//
	// Keys with empty prefix are reserved for end-users.
	// Properties set by external tools or internally by the participant server must use non-empty key prefixes.
	// Duplicate keys are disallowed by the semantics of the protobuf3 maps.
	// See: https://developers.google.com/protocol-buffers/docs/proto3#maps
	// Annotations may be a part of a modifiable resource.
	// Use the resource's update RPC to update its annotations.
	// In order to add a new annotation or update an existing one using an update RPC, provide the desired annotation in the update request.
	// In order to remove an annotation using an update RPC, provide the target annotation's key but set its value to the empty string in the update request.
	// Optional
	// Modifiable
	Annotations map[string]string `` /* 150-byte string literal not displayed */
	// contains filtered or unexported fields
}

type PackageDetails struct {

	// The identity of the Daml-LF package.
	// Must be a valid PackageIdString (as describe in “value.proto“).
	// Required
	PackageId string `protobuf:"bytes,1,opt,name=package_id,json=packageId,proto3" json:"package_id,omitempty"`
	// Size of the package in bytes.
	// The size of the package is given by the size of the “daml_lf“
	// ArchivePayload. See further details in “daml_lf.proto“.
	// Required
	PackageSize uint64 `protobuf:"varint,2,opt,name=package_size,json=packageSize,proto3" json:"package_size,omitempty"`
	// Indicates since when the package is known to the backing participant.
	// Required
	KnownSince *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=known_since,json=knownSince,proto3" json:"known_since,omitempty"`
	// Name of the package as defined by the package metadata
	Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	// Version of the package as defined by the package metadata
	Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type PackageManagementServiceClient interface {
	// Returns the details of all Daml-LF packages known to the backing participant.
	ListKnownPackages(ctx context.Context, in *ListKnownPackagesRequest, opts ...grpc.CallOption) (*ListKnownPackagesResponse, error)
	// 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.
	UploadDarFile(ctx context.Context, in *UploadDarFileRequest, opts ...grpc.CallOption) (*UploadDarFileResponse, error)
	// 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.
	ValidateDarFile(ctx context.Context, in *ValidateDarFileRequest, opts ...grpc.CallOption) (*ValidateDarFileResponse, error)
	// Update the vetted packages of this participant
	UpdateVettedPackages(ctx context.Context, in *UpdateVettedPackagesRequest, opts ...grpc.CallOption) (*UpdateVettedPackagesResponse, error)
}

type PackageManagementServiceServer interface {
	// Returns the details of all Daml-LF packages known to the backing participant.
	ListKnownPackages(context.Context, *ListKnownPackagesRequest) (*ListKnownPackagesResponse, error)
	// 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.
	UploadDarFile(context.Context, *UploadDarFileRequest) (*UploadDarFileResponse, error)
	// 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.
	ValidateDarFile(context.Context, *ValidateDarFileRequest) (*ValidateDarFileResponse, error)
	// Update the vetted packages of this participant
	UpdateVettedPackages(context.Context, *UpdateVettedPackagesRequest) (*UpdateVettedPackagesResponse, error)
	// contains filtered or unexported methods
}

type ParticipantPruningServiceClient interface {
	// Prune the ledger specifying the offset before and at which ledger transactions should be removed. Only returns when
	// the potentially long-running prune request ends successfully or with an error.
	Prune(ctx context.Context, in *PruneRequest, opts ...grpc.CallOption) (*PruneResponse, error)
}

type ParticipantPruningServiceServer interface {
	// Prune the ledger specifying the offset before and at which ledger transactions should be removed. Only returns when
	// the potentially long-running prune request ends successfully or with an error.
	Prune(context.Context, *PruneRequest) (*PruneResponse, error)
	// contains filtered or unexported methods
}

type PartyDetails struct {

	// The stable unique identifier of a Daml party.
	// Must be a valid PartyIdString (as described in “value.proto“).
	// Required
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// true if party is hosted by the participant and the party shares the same identity provider as the user issuing the request.
	// Optional
	IsLocal bool `protobuf:"varint,3,opt,name=is_local,json=isLocal,proto3" json:"is_local,omitempty"`
	// Participant-local metadata of this party.
	// Optional,
	// Modifiable
	LocalMetadata *ObjectMeta `protobuf:"bytes,4,opt,name=local_metadata,json=localMetadata,proto3" json:"local_metadata,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, there could be 3 options:
	//
	// 1. the party is managed by the default identity provider.
	// 2. party is not hosted by the participant.
	// 3. party is hosted by the participant, but is outside of the user's identity provider.
	IdentityProviderId string `protobuf:"bytes,5,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type PartyManagementServiceClient interface {
	// 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
	GetParticipantId(ctx context.Context, in *GetParticipantIdRequest, opts ...grpc.CallOption) (*GetParticipantIdResponse, error)
	// Get the party details of the given parties. Only known parties will be
	// returned in the list.
	GetParties(ctx context.Context, in *GetPartiesRequest, opts ...grpc.CallOption) (*GetPartiesResponse, error)
	// 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.
	ListKnownParties(ctx context.Context, in *ListKnownPartiesRequest, opts ...grpc.CallOption) (*ListKnownPartiesResponse, error)
	// 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
	AllocateParty(ctx context.Context, in *AllocatePartyRequest, opts ...grpc.CallOption) (*AllocatePartyResponse, error)
	// 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).
	AllocateExternalParty(ctx context.Context, in *AllocateExternalPartyRequest, opts ...grpc.CallOption) (*AllocateExternalPartyResponse, error)
	// Update selected modifiable participant-local attributes of a party details resource.
	// Can update the participant's local information for local parties.
	UpdatePartyDetails(ctx context.Context, in *UpdatePartyDetailsRequest, opts ...grpc.CallOption) (*UpdatePartyDetailsResponse, error)
	// Update the assignment of a party from one IDP to another.
	UpdatePartyIdentityProviderId(ctx context.Context, in *UpdatePartyIdentityProviderIdRequest, opts ...grpc.CallOption) (*UpdatePartyIdentityProviderIdResponse, error)
	// 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.
	GenerateExternalPartyTopology(ctx context.Context, in *GenerateExternalPartyTopologyRequest, opts ...grpc.CallOption) (*GenerateExternalPartyTopologyResponse, error)
}

type PartyManagementServiceServer interface {
	// 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
	GetParticipantId(context.Context, *GetParticipantIdRequest) (*GetParticipantIdResponse, error)
	// Get the party details of the given parties. Only known parties will be
	// returned in the list.
	GetParties(context.Context, *GetPartiesRequest) (*GetPartiesResponse, error)
	// 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.
	ListKnownParties(context.Context, *ListKnownPartiesRequest) (*ListKnownPartiesResponse, error)
	// 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
	AllocateParty(context.Context, *AllocatePartyRequest) (*AllocatePartyResponse, error)
	// 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).
	AllocateExternalParty(context.Context, *AllocateExternalPartyRequest) (*AllocateExternalPartyResponse, error)
	// Update selected modifiable participant-local attributes of a party details resource.
	// Can update the participant's local information for local parties.
	UpdatePartyDetails(context.Context, *UpdatePartyDetailsRequest) (*UpdatePartyDetailsResponse, error)
	// Update the assignment of a party from one IDP to another.
	UpdatePartyIdentityProviderId(context.Context, *UpdatePartyIdentityProviderIdRequest) (*UpdatePartyIdentityProviderIdResponse, error)
	// 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.
	GenerateExternalPartyTopology(context.Context, *GenerateExternalPartyTopologyRequest) (*GenerateExternalPartyTopologyResponse, error)
	// contains filtered or unexported methods
}

type PruneRequest struct {

	// Inclusive valid absolute offset (positive integer) up to which the ledger is to be pruned.
	// By default the following data is pruned:
	//
	//  1. All normal and divulged contracts that have been archived before
	//     `prune_up_to`.
	//  2. All transaction events and completions before `prune_up_to`
	//  3. All immediately divulged contracts created before `prune_up_to` independent of whether
	//     they were archived before `prune_up_to`.
	PruneUpTo int64 `protobuf:"varint,1,opt,name=prune_up_to,json=pruneUpTo,proto3" json:"prune_up_to,omitempty"`
	// Unique submission identifier.
	// Optional, defaults to a random identifier, used for logging.
	SubmissionId string `protobuf:"bytes,2,opt,name=submission_id,json=submissionId,proto3" json:"submission_id,omitempty"`
	// Deprecated flag used to prune all immediately and retroactively divulged contracts.
	// It is a no-op since the divulged contracts are pruned along with the deactivated contracts.
	PruneAllDivulgedContracts bool `` /* 141-byte string literal not displayed */
	// contains filtered or unexported fields
}

type PruneResponse struct {
	// contains filtered or unexported fields
}

type RequestStatistics struct {
	Envelopes   uint32 `protobuf:"varint,1,opt,name=envelopes,proto3" json:"envelopes,omitempty"`
	RequestSize uint32 `protobuf:"varint,2,opt,name=request_size,json=requestSize,proto3" json:"request_size,omitempty"`
	Recipients  uint32 `protobuf:"varint,3,opt,name=recipients,proto3" json:"recipients,omitempty"`
	// contains filtered or unexported fields
}

type RevokeUserRightsRequest struct {

	// The user from whom to revoke rights.
	// Required
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The rights to revoke.
	// Optional
	Rights []*Right `protobuf:"bytes,2,rep,name=rights,proto3" json:"rights,omitempty"`
	// The id of the “Identity Provider“
	// Optional, if not set, assume the user is managed by the default identity provider.
	IdentityProviderId string `protobuf:"bytes,3,opt,name=identity_provider_id,json=identityProviderId,proto3" json:"identity_provider_id,omitempty"`
	// contains filtered or unexported fields
}

type RevokeUserRightsResponse struct {

	// The rights that were actually revoked by the request.
	NewlyRevokedRights []*Right `protobuf:"bytes,1,rep,name=newly_revoked_rights,json=newlyRevokedRights,proto3" json:"newly_revoked_rights,omitempty"`
	// contains filtered or unexported fields
}

type Right struct {

	// Required
	//
	// Types that are valid to be assigned to Kind:
	//
	//	*Right_ParticipantAdmin_
	//	*Right_CanActAs_
	//	*Right_CanReadAs_
	//	*Right_IdentityProviderAdmin_
	//	*Right_CanReadAsAnyParty_
	//	*Right_CanExecuteAs_
	//	*Right_CanExecuteAsAnyParty_
	Kind isRight_Kind `protobuf_oneof:"kind"`
	// contains filtered or unexported fields
}

type Right_CanActAs struct {

	// The right to authorize commands for this party.
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// contains filtered or unexported fields
}

type Right_CanActAs_ struct {
	// The user can act as a specific party.
	CanActAs *Right_CanActAs `protobuf:"bytes,2,opt,name=can_act_as,json=canActAs,proto3,oneof"`
}

type Right_CanExecuteAs struct {

	// The right to prepare and execute submissions as this party.
	// This right does not entitle the user to perform any reads.
	// If reading is required, a separate ReadAs right must be added.
	// Right to execute as a party is also implicitly contained in the CanActAs right.
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// contains filtered or unexported fields
}

type Right_CanExecuteAsAnyParty struct {
	// contains filtered or unexported fields
}

type Right_CanExecuteAsAnyParty_ struct {
	// The user can prepare and execute submissions as any party on a participant.
	CanExecuteAsAnyParty *Right_CanExecuteAsAnyParty `protobuf:"bytes,7,opt,name=can_execute_as_any_party,json=canExecuteAsAnyParty,proto3,oneof"`
}

type Right_CanExecuteAs_ struct {
	// The user can prepare and execute submissions as a specific party.
	CanExecuteAs *Right_CanExecuteAs `protobuf:"bytes,6,opt,name=can_execute_as,json=canExecuteAs,proto3,oneof"`
}

type Right_CanReadAs struct {

	// The right to read ledger data visible to this party.
	Party string `protobuf:"bytes,1,opt,name=party,proto3" json:"party,omitempty"`
	// contains filtered or unexported fields
}

type Right_CanReadAsAnyParty struct {
	// contains filtered or unexported fields
}