v1

type ActiveContractsServiceClient interface {
	// Returns a stream of the latest snapshot of active contracts.
	// If there are no active contracts, the stream returns a single GetActiveContractsResponse message with the offset at which the snapshot has been taken.
	// Clients SHOULD use the offset in the last GetActiveContractsResponse message to continue streaming transactions with the transaction service.
	// Clients SHOULD NOT assume that the set of active contracts they receive reflects the state at the ledger end.
	GetActiveContracts(ctx context.Context, in *GetActiveContractsRequest, opts ...grpc.CallOption) (ActiveContractsService_GetActiveContractsClient, error)
}

type ActiveContractsServiceServer interface {
	// Returns a stream of the latest snapshot of active contracts.
	// If there are no active contracts, the stream returns a single GetActiveContractsResponse message with the offset at which the snapshot has been taken.
	// Clients SHOULD use the offset in the last GetActiveContractsResponse message to continue streaming transactions with the transaction service.
	// Clients SHOULD NOT assume that the set of active contracts they receive reflects the state at the ledger end.
	GetActiveContracts(*GetActiveContractsRequest, ActiveContractsService_GetActiveContractsServer) error
	// contains filtered or unexported methods
}

type ActiveContractsService_GetActiveContractsClient interface {
	Recv() (*GetActiveContractsResponse, error)
	grpc.ClientStream
}

type ActiveContractsService_GetActiveContractsServer interface {
	Send(*GetActiveContractsResponse) error
	grpc.ServerStream
}

type ArchivedEvent struct {

	// The ID of this particular event.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	EventId string `protobuf:"bytes,1,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	// The ID of the archived contract.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The template of the archived contract.
	// Required
	TemplateId *Identifier `protobuf:"bytes,3,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The parties that are notified of this event. For an “ArchivedEvent“,
	// these are the intersection of the stakeholders of the contract in
	// question and the parties specified in the “TransactionFilter“. The
	// stakeholders are the union of the signatories and the observers of
	// the contract.
	// Each one of its elements must be a valid PartyIdString (as described
	// in “value.proto“).
	// Required
	WitnessParties []string `protobuf:"bytes,4,rep,name=witness_parties,json=witnessParties,proto3" json:"witness_parties,omitempty"`
	// contains filtered or unexported fields
}

type Checkpoint struct {

	// All commands with a maximum record time below this value MUST be considered lost if their completion has not arrived before this checkpoint.
	// Required
	RecordTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=record_time,json=recordTime,proto3" json:"record_time,omitempty"`
	// May be used in a subsequent CompletionStreamRequest to resume the consumption of this stream at a later time.
	// Required
	Offset *LedgerOffset `protobuf:"bytes,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

type Command struct {

	// Types that are assignable to Command:
	//
	//	*Command_Create
	//	*Command_Exercise
	//	*Command_ExerciseByKey
	//	*Command_CreateAndExercise
	Command isCommand_Command `protobuf_oneof:"command"`
	// contains filtered or unexported fields
}

type CommandCompletionServiceClient interface {
	// Subscribe to command completion events.
	CompletionStream(ctx context.Context, in *CompletionStreamRequest, opts ...grpc.CallOption) (CommandCompletionService_CompletionStreamClient, error)
	// Returns the offset after the latest completion.
	CompletionEnd(ctx context.Context, in *CompletionEndRequest, opts ...grpc.CallOption) (*CompletionEndResponse, error)
}

type CommandCompletionServiceServer interface {
	// Subscribe to command completion events.
	CompletionStream(*CompletionStreamRequest, CommandCompletionService_CompletionStreamServer) error
	// Returns the offset after the latest completion.
	CompletionEnd(context.Context, *CompletionEndRequest) (*CompletionEndResponse, error)
	// contains filtered or unexported methods
}

type CommandCompletionService_CompletionStreamClient interface {
	Recv() (*CompletionStreamResponse, error)
	grpc.ClientStream
}

type CommandCompletionService_CompletionStreamServer interface {
	Send(*CompletionStreamResponse) error
	grpc.ServerStream
}

type CommandDeduplicationFeatures struct {
	DeduplicationPeriodSupport *CommandDeduplicationPeriodSupport `` /* 141-byte string literal not displayed */
	DeduplicationType          CommandDeduplicationType           `` /* 166-byte string literal not displayed */
	// The ledger will reject any requests which specify a deduplication period which exceeds the specified max deduplication duration.
	// This is also enforced for ledgers that convert deduplication periods specified as offsets to durations.
	MaxDeduplicationDurationEnforced bool `` /* 162-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CommandDeduplicationPeriodSupport struct {
	OffsetSupport   CommandDeduplicationPeriodSupport_OffsetSupport   `` /* 177-byte string literal not displayed */
	DurationSupport CommandDeduplicationPeriodSupport_DurationSupport `` /* 185-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CommandDeduplicationPeriodSupport_DurationSupport int32

type CommandDeduplicationPeriodSupport_OffsetSupport int32

type CommandDeduplicationType int32

type CommandServiceClient interface {
	// Submits a single composite command and waits for its result.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWait(ctx context.Context, in *SubmitAndWaitRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Submits a single composite command, waits for its result, and returns the transaction id.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWaitForTransactionId(ctx context.Context, in *SubmitAndWaitRequest, opts ...grpc.CallOption) (*SubmitAndWaitForTransactionIdResponse, error)
	// Submits a single composite command, waits for its result, and returns the transaction.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWaitForTransaction(ctx context.Context, in *SubmitAndWaitRequest, opts ...grpc.CallOption) (*SubmitAndWaitForTransactionResponse, error)
	// Submits a single composite command, waits for its result, and returns the transaction tree.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWaitForTransactionTree(ctx context.Context, in *SubmitAndWaitRequest, opts ...grpc.CallOption) (*SubmitAndWaitForTransactionTreeResponse, error)
}

type CommandServiceServer interface {
	// Submits a single composite command and waits for its result.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWait(context.Context, *SubmitAndWaitRequest) (*emptypb.Empty, error)
	// Submits a single composite command, waits for its result, and returns the transaction id.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWaitForTransactionId(context.Context, *SubmitAndWaitRequest) (*SubmitAndWaitForTransactionIdResponse, error)
	// Submits a single composite command, waits for its result, and returns the transaction.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWaitForTransaction(context.Context, *SubmitAndWaitRequest) (*SubmitAndWaitForTransactionResponse, error)
	// Submits a single composite command, waits for its result, and returns the transaction tree.
	// Propagates the gRPC error of failed submissions including Daml interpretation errors.
	SubmitAndWaitForTransactionTree(context.Context, *SubmitAndWaitRequest) (*SubmitAndWaitForTransactionTreeResponse, error)
	// contains filtered or unexported methods
}

type CommandSubmissionServiceClient interface {
	// Submit a single composite command.
	Submit(ctx context.Context, in *SubmitRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type CommandSubmissionServiceServer interface {
	// Submit a single composite command.
	Submit(context.Context, *SubmitRequest) (*emptypb.Empty, error)
	// contains filtered or unexported methods
}

type Command_Create struct {
	Create *CreateCommand `protobuf:"bytes,1,opt,name=create,proto3,oneof"`
}

type Command_CreateAndExercise struct {
	CreateAndExercise *CreateAndExerciseCommand `protobuf:"bytes,3,opt,name=createAndExercise,proto3,oneof"`
}

type Command_Exercise struct {
	Exercise *ExerciseCommand `protobuf:"bytes,2,opt,name=exercise,proto3,oneof"`
}

type Command_ExerciseByKey struct {
	ExerciseByKey *ExerciseByKeyCommand `protobuf:"bytes,4,opt,name=exerciseByKey,proto3,oneof"`
}

type Commands struct {

	// Must correspond to the ledger ID reported by the Ledger Identification Service.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	LedgerId string `protobuf:"bytes,1,opt,name=ledger_id,json=ledgerId,proto3" json:"ledger_id,omitempty"`
	// Identifier of the on-ledger workflow that this command is a part of.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	WorkflowId string `protobuf:"bytes,2,opt,name=workflow_id,json=workflowId,proto3" json:"workflow_id,omitempty"`
	// Uniquely identifies the application or participant user that issued the command.
	// Must be a valid ApplicationIdString (as described in “value.proto“).
	// Required unless authentication is used with a user token or a custom token specifying an application-id.
	// In that case, the token's user-id, respectively application-id, will be used for the request's application_id.
	ApplicationId string `protobuf:"bytes,3,opt,name=application_id,json=applicationId,proto3" json:"application_id,omitempty"`
	// Uniquely identifies the command.
	// The triple (application_id, party + act_as, command_id) constitutes the change ID for the intended ledger change,
	// where party + act_as is interpreted as a set of party names.
	// The change ID can be used for matching the intended ledger changes with all their completions.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	CommandId string `protobuf:"bytes,4,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// Party on whose behalf the command should be executed.
	// If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request
	// to act on behalf of the given party.
	// Must be a valid PartyIdString (as described in “value.proto“).
	// Deprecated in favor of the “act_as“ field. If both are set, then the effective list of parties on whose
	// behalf the command should be executed is the union of all parties listed in “party“ and “act_as“.
	// Optional
	Party string `protobuf:"bytes,5,opt,name=party,proto3" json:"party,omitempty"`
	// Individual elements of this atomic command. Must be non-empty.
	// Required
	Commands []*Command `protobuf:"bytes,8,rep,name=commands,proto3" json:"commands,omitempty"`
	// Specifies the deduplication period for the change ID.
	// If omitted, the participant will assume the configured maximum deduplication time (see
	// “ledger_configuration_service.proto“).
	//
	// Types that are assignable to DeduplicationPeriod:
	//
	//	*Commands_DeduplicationTime
	//	*Commands_DeduplicationDuration
	//	*Commands_DeduplicationOffset
	DeduplicationPeriod isCommands_DeduplicationPeriod `protobuf_oneof:"deduplication_period"`
	// Lower bound for the ledger time assigned to the resulting transaction.
	// Note: The ledger time of a transaction is assigned as part of command interpretation.
	// Use this property if you expect that command interpretation will take a considerate amount of time, such that by
	// the time the resulting transaction is sequenced, its assigned ledger time is not valid anymore.
	// Must not be set at the same time as min_ledger_time_rel.
	// Optional
	MinLedgerTimeAbs *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=min_ledger_time_abs,json=minLedgerTimeAbs,proto3" json:"min_ledger_time_abs,omitempty"`
	// Same as min_ledger_time_abs, but specified as a duration, starting from the time the command is received by the server.
	// Must not be set at the same time as min_ledger_time_abs.
	// Optional
	MinLedgerTimeRel *durationpb.Duration `protobuf:"bytes,11,opt,name=min_ledger_time_rel,json=minLedgerTimeRel,proto3" json:"min_ledger_time_rel,omitempty"`
	// Set of parties on whose behalf the command should be executed.
	// If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request
	// to act on behalf of each of the given parties.
	// This field supersedes the “party“ field. The effective set of parties on whose behalf the command
	// should be executed is the union of all parties listed in “party“ and “act_as“, which must be non-empty.
	// Each element must be a valid PartyIdString (as described in “value.proto“).
	// Optional
	ActAs []string `protobuf:"bytes,12,rep,name=act_as,json=actAs,proto3" json:"act_as,omitempty"`
	// Set of parties on whose behalf (in addition to all parties listed in “act_as“) contracts can be retrieved.
	// This affects Daml operations such as “fetch“, “fetchByKey“, “lookupByKey“, “exercise“, and “exerciseByKey“.
	// Note: A participant node of a Daml network can host multiple parties. Each contract present on the participant
	// node is only visible to a subset of these parties. A command can only use contracts that are visible to at least
	// one of the parties in “act_as“ or “read_as“. This visibility check is independent from the Daml authorization
	// rules for fetch operations.
	// If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request
	// to read contract data on behalf of each of the given parties.
	// Optional
	ReadAs []string `protobuf:"bytes,13,rep,name=read_as,json=readAs,proto3" json:"read_as,omitempty"`
	// A unique identifier to distinguish completions for different submissions with the same change ID.
	// Typically a random UUID. Applications are expected to use a different UUID for each retry of a submission
	// with the same change ID.
	// Must be a valid LedgerString (as described in “value.proto“).
	//
	// If omitted, the participant or the committer may set a value of their choice.
	// Optional
	SubmissionId string `protobuf:"bytes,14,opt,name=submission_id,json=submissionId,proto3" json:"submission_id,omitempty"`
	// Additional contracts used to resolve contract & contract key lookups.
	// Optional
	DisclosedContracts []*DisclosedContract `protobuf:"bytes,17,rep,name=disclosed_contracts,json=disclosedContracts,proto3" json:"disclosed_contracts,omitempty"`
	// contains filtered or unexported fields
}

type Commands_DeduplicationDuration struct {
	// Specifies the length of the deduplication period.
	// It is interpreted relative to the local clock at some point during the submission's processing.
	// Must be non-negative. Must not exceed the maximum deduplication time (see
	// “ledger_configuration_service.proto“).
	DeduplicationDuration *durationpb.Duration `protobuf:"bytes,15,opt,name=deduplication_duration,json=deduplicationDuration,proto3,oneof"`
}

type Commands_DeduplicationOffset struct {
	// Specifies the start of the deduplication period by a completion stream offset (exclusive).
	// Must be a valid LedgerString (as described in “ledger_offset.proto“).
	DeduplicationOffset string `protobuf:"bytes,16,opt,name=deduplication_offset,json=deduplicationOffset,proto3,oneof"`
}

type Commands_DeduplicationTime struct {
	// Specifies the length of the deduplication period.
	// Same semantics apply as for `deduplication_duration`.
	// Must be non-negative. Must not exceed the maximum deduplication time (see
	// “ledger_configuration_service.proto“).
	//
	// Deprecated: Do not use.
	DeduplicationTime *durationpb.Duration `protobuf:"bytes,9,opt,name=deduplication_time,json=deduplicationTime,proto3,oneof"`
}

type Completion struct {

	// The ID of the succeeded or failed command.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	CommandId string `protobuf:"bytes,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// Identifies the exact type of the error.
	// It uses the same format of conveying error details as it is used for the RPC responses of the APIs.
	// Optional
	Status *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	// The transaction_id of the transaction that resulted from the command with command_id.
	// Only set for successfully executed commands.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	TransactionId string `protobuf:"bytes,3,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
	// The application-id or user-id that was used for the submission, as described in “commands.proto“.
	// Must be a valid ApplicationIdString (as described in “value.proto“).
	// Optional for historic completions where this data is not available.
	ApplicationId string `protobuf:"bytes,4,opt,name=application_id,json=applicationId,proto3" json:"application_id,omitempty"`
	// The set of parties on whose behalf the commands were executed.
	// Contains the union of “party“ and “act_as“ from “commands.proto“.
	// The order of the parties need not be the same as in the submission.
	// Each element must be a valid PartyIdString (as described in “value.proto“).
	// Optional for historic completions where this data is not available.
	ActAs []string `protobuf:"bytes,5,rep,name=act_as,json=actAs,proto3" json:"act_as,omitempty"`
	// The submission ID this completion refers to, as described in “commands.proto“.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	SubmissionId string `protobuf:"bytes,6,opt,name=submission_id,json=submissionId,proto3" json:"submission_id,omitempty"`
	// The actual deduplication window used for the submission, which is derived from
	// “Commands.deduplication_period“. The ledger may convert the deduplication period into other
	// descriptions and extend the period in implementation-specified ways.
	//
	// Used to audit the deduplication guarantee described in “commands.proto“.
	//
	// Optional; the deduplication guarantee applies even if the completion omits this field.
	//
	// Types that are assignable to DeduplicationPeriod:
	//
	//	*Completion_DeduplicationOffset
	//	*Completion_DeduplicationDuration
	DeduplicationPeriod isCompletion_DeduplicationPeriod `protobuf_oneof:"deduplication_period"`
	// contains filtered or unexported fields
}

type CompletionEndRequest struct {

	// Must correspond to the ledger ID reported by the Ledger Identification Service.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	LedgerId string `protobuf:"bytes,1,opt,name=ledger_id,json=ledgerId,proto3" json:"ledger_id,omitempty"`
	// contains filtered or unexported fields
}

type CompletionEndResponse struct {

	// This offset can be used in a CompletionStreamRequest message.
	// Required
	Offset *LedgerOffset `protobuf:"bytes,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

type CompletionStreamRequest struct {

	// Must correspond to the ledger id reported by the Ledger Identification Service.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	LedgerId string `protobuf:"bytes,1,opt,name=ledger_id,json=ledgerId,proto3" json:"ledger_id,omitempty"`
	// Only completions of commands submitted with the same application_id will be visible in the stream.
	// Must be a valid ApplicationIdString (as described in “value.proto“).
	// Required unless authentication is used with a user token or a custom token specifying an application-id.
	// In that case, the token's user-id, respectively application-id, will be used for the request's application_id.
	ApplicationId string `protobuf:"bytes,2,opt,name=application_id,json=applicationId,proto3" json:"application_id,omitempty"`
	// Non-empty list of parties whose data should be included.
	// Only completions of commands for which at least one of the “act_as“ parties is in the given set of parties
	// will be visible in the stream.
	// Must be a valid PartyIdString (as described in “value.proto“).
	// Required
	Parties []string `protobuf:"bytes,3,rep,name=parties,proto3" json:"parties,omitempty"`
	// This field indicates the minimum offset for completions. This can be used to resume an earlier completion stream.
	// This offset is exclusive: the response will only contain commands whose offset is strictly greater than this.
	// Optional, if not set the ledger uses the current ledger end offset instead.
	Offset *LedgerOffset `protobuf:"bytes,4,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

type CompletionStreamResponse struct {

	// This checkpoint may be used to restart consumption.  The
	// checkpoint is after any completions in this response.
	// Optional
	Checkpoint *Checkpoint `protobuf:"bytes,1,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
	// If set, one or more completions.
	Completions []*Completion `protobuf:"bytes,2,rep,name=completions,proto3" json:"completions,omitempty"`
	// contains filtered or unexported fields
}

type Completion_DeduplicationDuration struct {
	// Specifies the length of the deduplication period.
	// It is measured in record time of completions.
	//
	// Must be non-negative.
	DeduplicationDuration *durationpb.Duration `protobuf:"bytes,9,opt,name=deduplication_duration,json=deduplicationDuration,proto3,oneof"`
}

type Completion_DeduplicationOffset struct {
	// Specifies the start of the deduplication period by a completion stream offset (exclusive).
	//
	// Must be a valid LedgerString (as described in “value.proto“).
	DeduplicationOffset string `protobuf:"bytes,8,opt,name=deduplication_offset,json=deduplicationOffset,proto3,oneof"`
}

type ContractMetadata struct {

	// Ledger effective time of the transaction that created the contract.
	// Required
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// Hash of the contract key if defined.
	// Optional
	ContractKeyHash []byte `protobuf:"bytes,2,opt,name=contract_key_hash,json=contractKeyHash,proto3" json:"contract_key_hash,omitempty"`
	// Driver-specific metadata. This is opaque and cannot be decoded.
	// Optional
	DriverMetadata []byte `protobuf:"bytes,3,opt,name=driver_metadata,json=driverMetadata,proto3" json:"driver_metadata,omitempty"`
	// contains filtered or unexported fields
}

type CreateAndExerciseCommand struct {

	// The template of the contract the client wants to create.
	// Required
	TemplateId *Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The arguments required for creating a contract from this template.
	// Required
	CreateArguments *Record `protobuf:"bytes,2,opt,name=create_arguments,json=createArguments,proto3" json:"create_arguments,omitempty"`
	// The name of the choice the client wants to exercise.
	// Must be a valid NameString (as described in “value.proto“).
	// Required
	Choice string `protobuf:"bytes,3,opt,name=choice,proto3" json:"choice,omitempty"`
	// The argument for this choice.
	// Required
	ChoiceArgument *Value `protobuf:"bytes,4,opt,name=choice_argument,json=choiceArgument,proto3" json:"choice_argument,omitempty"`
	// contains filtered or unexported fields
}

type CreateCommand struct {

	// The template of contract the client wants to create.
	// Required
	TemplateId *Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The arguments required for creating a contract from this template.
	// Required
	CreateArguments *Record `protobuf:"bytes,2,opt,name=create_arguments,json=createArguments,proto3" json:"create_arguments,omitempty"`
	// contains filtered or unexported fields
}

type CreatedEvent struct {

	// The ID of this particular event.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	EventId string `protobuf:"bytes,1,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	// The ID of the created contract.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The template of the created contract.
	// Required
	TemplateId *Identifier `protobuf:"bytes,3,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The key of the created contract.
	// This will be set if and only if “create_arguments“ is set and “template_id“ defines a contract key.
	// Optional
	ContractKey *Value `protobuf:"bytes,7,opt,name=contract_key,json=contractKey,proto3" json:"contract_key,omitempty"`
	// The arguments that have been used to create the contract.
	// Set either:
	//   - if there was a party, which is in the “witness_parties“ of this event,
	//     and for which an “InclusiveFilters“ exists with the “template_id“ of this event
	//     among the “template_ids“,
	//   - or if there was a party, which is in the “witness_parties“ of this event,
	//     and for which a wildcard filter exists (“Filters“ without “InclusiveFilters“,
	//     or with an “InclusiveFilters“ with empty “template_ids“ and empty “interface_filters“).
	//
	// Optional
	CreateArguments *Record `protobuf:"bytes,4,opt,name=create_arguments,json=createArguments,proto3" json:"create_arguments,omitempty"`
	// Opaque representation of contract payload intended for forwarding
	// to an API server as a contract disclosed as part of a command
	// submission.
	// Optional
	CreateArgumentsBlob *anypb.Any `protobuf:"bytes,12,opt,name=create_arguments_blob,json=createArgumentsBlob,proto3" json:"create_arguments_blob,omitempty"`
	// Interface views specified in the transaction filter.
	// Includes an “InterfaceView“ for each interface for which there is a “InterfaceFilter“ with
	//   - its party in the “witness_parties“ of this event,
	//   - and which is implemented by the template of this event,
	//   - and which has “include_interface_view“ set.
	//
	// Optional
	InterfaceViews []*InterfaceView `protobuf:"bytes,11,rep,name=interface_views,json=interfaceViews,proto3" json:"interface_views,omitempty"`
	// The parties that are notified of this event. When a “CreatedEvent“
	// is returned as part of a transaction tree, this will include all
	// the parties specified in the “TransactionFilter“ that are informees
	// of the event. If served as part of a flat transaction those will
	// be limited to all parties specified in the “TransactionFilter“ that
	// are stakeholders of the contract (i.e. either signatories or observers).
	// Required
	WitnessParties []string `protobuf:"bytes,5,rep,name=witness_parties,json=witnessParties,proto3" json:"witness_parties,omitempty"`
	// The signatories for this contract as specified by the template.
	// Required
	Signatories []string `protobuf:"bytes,8,rep,name=signatories,proto3" json:"signatories,omitempty"`
	// The observers for this contract as specified explicitly by the template or implicitly as choice controllers.
	// This field never contains parties that are signatories.
	// Required
	Observers []string `protobuf:"bytes,9,rep,name=observers,proto3" json:"observers,omitempty"`
	// The agreement text of the contract.
	// We use StringValue to properly reflect optionality on the wire for backwards compatibility.
	// This is necessary since the empty string is an acceptable (and in fact the default) agreement
	// text, but also the default string in protobuf.
	// This means a newer client works with an older sandbox seamlessly.
	// Optional
	AgreementText *wrapperspb.StringValue `protobuf:"bytes,6,opt,name=agreement_text,json=agreementText,proto3" json:"agreement_text,omitempty"`
	// Metadata of the contract. Required for contracts created
	// after the introduction of explicit disclosure.
	Metadata *ContractMetadata `protobuf:"bytes,10,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type DisclosedContract struct {

	// The template id of the contract.
	// Required
	TemplateId *Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The contract id
	// Required
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The contract arguments
	//
	// Types that are assignable to Arguments:
	//
	//	*DisclosedContract_CreateArguments
	//	*DisclosedContract_CreateArgumentsBlob
	Arguments isDisclosedContract_Arguments `protobuf_oneof:"arguments"`
	// The contract metadata from the create event.
	// Required
	Metadata *ContractMetadata `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type DisclosedContract_CreateArguments struct {
	// The contract arguments as typed Record
	CreateArguments *Record `protobuf:"bytes,3,opt,name=create_arguments,json=createArguments,proto3,oneof"`
}

type DisclosedContract_CreateArgumentsBlob struct {
	// The contract arguments specified using an opaque blob extracted from the “create_arguments_blob“ field
	// of a “com.daml.ledger.api.v1.CreatedEvent“.
	CreateArgumentsBlob *anypb.Any `protobuf:"bytes,5,opt,name=create_arguments_blob,json=createArgumentsBlob,proto3,oneof"`
}

type Enum struct {

	// Omitted from the transaction stream when verbose streaming is not enabled.
	// Optional when submitting commands.
	EnumId *Identifier `protobuf:"bytes,1,opt,name=enum_id,json=enumId,proto3" json:"enum_id,omitempty"`
	// Determines which of the Variant's alternatives is encoded in this message.
	// Must be a valid NameString.
	// Required
	Constructor string `protobuf:"bytes,2,opt,name=constructor,proto3" json:"constructor,omitempty"`
	// contains filtered or unexported fields
}

type Event struct {

	// Types that are assignable to Event:
	//
	//	*Event_Created
	//	*Event_Archived
	Event isEvent_Event `protobuf_oneof:"event"`
	// contains filtered or unexported fields
}

type Event_Archived struct {
	Archived *ArchivedEvent `protobuf:"bytes,3,opt,name=archived,proto3,oneof"`
}

type Event_Created struct {
	Created *CreatedEvent `protobuf:"bytes,1,opt,name=created,proto3,oneof"`
}

type ExerciseByKeyCommand struct {

	// The template of contract the client wants to exercise.
	// Required
	TemplateId *Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The key of the contract the client wants to exercise upon.
	// Required
	ContractKey *Value `protobuf:"bytes,2,opt,name=contract_key,json=contractKey,proto3" json:"contract_key,omitempty"`
	// The name of the choice the client wants to exercise.
	// Must be a valid NameString (as described in “value.proto“)
	// Required
	Choice string `protobuf:"bytes,3,opt,name=choice,proto3" json:"choice,omitempty"`
	// The argument for this choice.
	// Required
	ChoiceArgument *Value `protobuf:"bytes,4,opt,name=choice_argument,json=choiceArgument,proto3" json:"choice_argument,omitempty"`
	// contains filtered or unexported fields
}

type ExerciseCommand struct {

	// The template of contract the client wants to exercise.
	// Required
	TemplateId *Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The ID of the contract the client wants to exercise upon.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The name of the choice the client wants to exercise.
	// Must be a valid NameString (as described in “value.proto“)
	// Required
	Choice string `protobuf:"bytes,3,opt,name=choice,proto3" json:"choice,omitempty"`
	// The argument for this choice.
	// Required
	ChoiceArgument *Value `protobuf:"bytes,4,opt,name=choice_argument,json=choiceArgument,proto3" json:"choice_argument,omitempty"`
	// contains filtered or unexported fields
}

type ExercisedEvent struct {

	// The ID of this particular event.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	EventId string `protobuf:"bytes,1,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	// The ID of the target contract.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The template of the target contract.
	// Required
	TemplateId *Identifier `protobuf:"bytes,3,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The interface where the choice is defined, if inherited.
	// Optional
	InterfaceId *Identifier `protobuf:"bytes,13,opt,name=interface_id,json=interfaceId,proto3" json:"interface_id,omitempty"`
	// The choice that was exercised on the target contract.
	// Must be a valid NameString (as described in “value.proto“).
	// Required
	Choice string `protobuf:"bytes,5,opt,name=choice,proto3" json:"choice,omitempty"`
	// The argument of the exercised choice.
	// Required
	ChoiceArgument *Value `protobuf:"bytes,6,opt,name=choice_argument,json=choiceArgument,proto3" json:"choice_argument,omitempty"`
	// The parties that exercised the choice.
	// Each element must be a valid PartyIdString (as described in “value.proto“).
	// Required
	ActingParties []string `protobuf:"bytes,7,rep,name=acting_parties,json=actingParties,proto3" json:"acting_parties,omitempty"`
	// If true, the target contract may no longer be exercised.
	// Required
	Consuming bool `protobuf:"varint,8,opt,name=consuming,proto3" json:"consuming,omitempty"`
	// The parties that are notified of this event. The witnesses of an exercise
	// node will depend on whether the exercise was consuming or not.
	// If consuming, the witnesses are the union of the stakeholders and
	// the actors.
	// If not consuming, the witnesses are the union of the signatories and
	// the actors. Note that the actors might not necessarily be observers
	// and thus signatories. This is the case when the controllers of a
	// choice are specified using "flexible controllers", using the
	// “choice ... controller“ syntax, and said controllers are not
	// explicitly marked as observers.
	// Each element must be a valid PartyIdString (as described in “value.proto“).
	// Required
	WitnessParties []string `protobuf:"bytes,10,rep,name=witness_parties,json=witnessParties,proto3" json:"witness_parties,omitempty"`
	// References to further events in the same transaction that appeared as a result of this “ExercisedEvent“.
	// It contains only the immediate children of this event, not all members of the subtree rooted at this node.
	// The order of the children is the same as the event order in the transaction.
	// Each element must be a valid LedgerString (as described in “value.proto“).
	// Optional
	ChildEventIds []string `protobuf:"bytes,11,rep,name=child_event_ids,json=childEventIds,proto3" json:"child_event_ids,omitempty"`
	// The result of exercising the choice.
	// Required
	ExerciseResult *Value `protobuf:"bytes,12,opt,name=exercise_result,json=exerciseResult,proto3" json:"exercise_result,omitempty"`
	// contains filtered or unexported fields
}

type ExperimentalCommitterEventLog struct {
	EventLogType ExperimentalCommitterEventLog_CommitterEventLogType `` /* 180-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ExperimentalCommitterEventLog_CommitterEventLogType int32

type ExperimentalContractIds struct {
	V1 ExperimentalContractIds_ContractIdV1Support `` /* 130-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ExperimentalContractIds_ContractIdV1Support int32

type ExperimentalExplicitDisclosure struct {
	Supported bool `protobuf:"varint,1,opt,name=supported,proto3" json:"supported,omitempty"`
	// contains filtered or unexported fields
}

type ExperimentalFeatures struct {

	// Deprecated: Do not use.
	SelfServiceErrorCodes               *ExperimentalSelfServiceErrorCodes               `` /* 128-byte string literal not displayed */
	StaticTime                          *ExperimentalStaticTime                          `protobuf:"bytes,2,opt,name=static_time,json=staticTime,proto3" json:"static_time,omitempty"`
	CommandDeduplication                *CommandDeduplicationFeatures                    `protobuf:"bytes,3,opt,name=command_deduplication,json=commandDeduplication,proto3" json:"command_deduplication,omitempty"`
	OptionalLedgerId                    *ExperimentalOptionalLedgerId                    `protobuf:"bytes,4,opt,name=optional_ledger_id,json=optionalLedgerId,proto3" json:"optional_ledger_id,omitempty"`
	ContractIds                         *ExperimentalContractIds                         `protobuf:"bytes,5,opt,name=contract_ids,json=contractIds,proto3" json:"contract_ids,omitempty"`
	CommitterEventLog                   *ExperimentalCommitterEventLog                   `protobuf:"bytes,6,opt,name=committer_event_log,json=committerEventLog,proto3" json:"committer_event_log,omitempty"`
	ExplicitDisclosure                  *ExperimentalExplicitDisclosure                  `protobuf:"bytes,7,opt,name=explicit_disclosure,json=explicitDisclosure,proto3" json:"explicit_disclosure,omitempty"`
	UserAndPartyLocalMetadataExtensions *ExperimentalUserAndPartyLocalMetadataExtensions `` /* 174-byte string literal not displayed */
	// contains filtered or unexported fields
}

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

type ExperimentalStaticTime struct {
	Supported bool `protobuf:"varint,1,opt,name=supported,proto3" json:"supported,omitempty"`
	// contains filtered or unexported fields
}

type ExperimentalUserAndPartyLocalMetadataExtensions struct {
	Supported bool `protobuf:"varint,1,opt,name=supported,proto3" json:"supported,omitempty"`
	// contains filtered or unexported fields
}

type FeaturesDescriptor struct {

	// If set, then the Ledger API server supports user management.
	// It is recommended that clients query this field to gracefully adjust their behavior for
	// ledgers that do not support user management.
	UserManagement *UserManagementFeature `protobuf:"bytes,2,opt,name=user_management,json=userManagement,proto3" json:"user_management,omitempty"`
	// Features under development or features that are used
	// for ledger implementation testing purposes only.
	//
	// Daml applications SHOULD not depend on these in production.
	Experimental *ExperimentalFeatures `protobuf:"bytes,1,opt,name=experimental,proto3" json:"experimental,omitempty"`
	// contains filtered or unexported fields
}

type Filters struct {

	// If set, then contracts matching any of the “InclusiveFilters“ match
	// this filter.
	// If not set, or if “InclusiveFilters“ has empty “template_ids“ and empty “interface_filters“:
	// any contract matches this filter.
	// Optional
	Inclusive *InclusiveFilters `protobuf:"bytes,1,opt,name=inclusive,proto3" json:"inclusive,omitempty"`
	// contains filtered or unexported fields
}

type GenMap struct {
	Entries []*GenMap_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	// contains filtered or unexported fields
}

type GenMap_Entry struct {
	Key   *Value `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value *Value `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type GetActiveContractsRequest struct {

	// Must correspond to the ledger ID reported by the Ledger Identification Service.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	LedgerId string `protobuf:"bytes,1,opt,name=ledger_id,json=ledgerId,proto3" json:"ledger_id,omitempty"`
	// Templates to include in the served snapshot, per party.
	// Required
	Filter *TransactionFilter `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
	// If enabled, values served over the API will contain more information than strictly necessary to interpret the data.
	// In particular, setting the verbose flag to true triggers the ledger to include labels for record fields.
	// Optional
	Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"`
	// contains filtered or unexported fields
}

type GetActiveContractsResponse struct {

	// Included in the last message.
	// The client should start consuming the transactions endpoint with this offset.
	// The format of this field is described in “ledger_offset.proto“.
	// Required
	Offset string `protobuf:"bytes,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// The workflow that created the contracts.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	WorkflowId string `protobuf:"bytes,2,opt,name=workflow_id,json=workflowId,proto3" json:"workflow_id,omitempty"`
	// The list of contracts that were introduced by the workflow with “workflow_id“ at the offset.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	ActiveContracts []*CreatedEvent `protobuf:"bytes,3,rep,name=active_contracts,json=activeContracts,proto3" json:"active_contracts,omitempty"`
	// contains filtered or unexported fields
}

type GetFlatTransactionResponse struct {
	Transaction *Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
	// contains filtered or unexported fields
}

type GetLedgerApiVersionRequest struct {

	// Must correspond to the ledger ID reported by the Ledger Identification Service.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Optional
	LedgerId string `protobuf:"bytes,1,opt,name=ledger_id,json=ledgerId,proto3" json:"ledger_id,omitempty"`
	// contains filtered or unexported fields
}