v2

type ActiveContract struct {

	// Required
	// The event as it appeared in the context of its last update (i.e. daml transaction or
	// reassignment). In particular, the last offset, node_id pair is preserved.
	// The last update is the most recent update created or assigned this contract on synchronizer_id synchronizer.
	// The offset of the CreatedEvent might point to an already pruned update, therefore it cannot necessarily be used
	// for lookups.
	CreatedEvent *CreatedEvent `protobuf:"bytes,1,opt,name=created_event,json=createdEvent,proto3" json:"created_event,omitempty"`
	// A valid synchronizer id
	// Required
	SynchronizerId string `protobuf:"bytes,2,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// Each corresponding assigned and unassigned event has the same reassignment_counter. This strictly increases
	// with each unassign command for the same contract. Creation of the contract corresponds to reassignment_counter
	// equals zero.
	// This field will be the reassignment_counter of the latest observable activation event on this synchronizer, which is
	// before the active_at_offset.
	// Required
	ReassignmentCounter uint64 `protobuf:"varint,3,opt,name=reassignment_counter,json=reassignmentCounter,proto3" json:"reassignment_counter,omitempty"`
	// contains filtered or unexported fields
}

type Archived struct {

	// Required
	ArchivedEvent *ArchivedEvent `protobuf:"bytes,1,opt,name=archived_event,json=archivedEvent,proto3" json:"archived_event,omitempty"`
	// Required
	// The synchronizer which sequenced the archival of the contract
	SynchronizerId string `protobuf:"bytes,2,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// contains filtered or unexported fields
}

type ArchivedEvent struct {

	// The offset of origin.
	// Offsets are managed by the participant nodes.
	// Transactions can thus NOT be assumed to have the same offsets on different participant nodes.
	// Required, it is a valid absolute offset (positive integer)
	Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// The position of this event in the originating transaction or reassignment.
	// Node IDs are not necessarily equal across participants,
	// as these may see different projections/parts of transactions.
	// Required, must be valid node ID (non-negative integer)
	NodeId int32 `protobuf:"varint,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// The ID of the archived contract.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,3,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// Identifies the template that defines the choice that archived the contract.
	// This template's package-id may differ from the target contract's package-id
	// if the target contract has been upgraded or downgraded.
	//
	// The identifier uses the package-id reference format.
	//
	// Required
	TemplateId *Identifier `protobuf:"bytes,4,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,5,rep,name=witness_parties,json=witnessParties,proto3" json:"witness_parties,omitempty"`
	// The package name of the contract.
	// Required
	PackageName string `protobuf:"bytes,6,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	// The interfaces implemented by the target template that have been
	// matched from the interface filter query.
	// Populated only in case interface filters with include_interface_view set.
	//
	// If defined, the identifier uses the package-id reference format.
	//
	// Optional
	ImplementedInterfaces []*Identifier `protobuf:"bytes,7,rep,name=implemented_interfaces,json=implementedInterfaces,proto3" json:"implemented_interfaces,omitempty"`
	// contains filtered or unexported fields
}

type AssignCommand struct {

	// The ID from the unassigned event to be completed by this assignment.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ReassignmentId string `protobuf:"bytes,1,opt,name=reassignment_id,json=reassignmentId,proto3" json:"reassignment_id,omitempty"`
	// The ID of the source synchronizer
	// Must be a valid synchronizer id
	// Required
	Source string `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
	// The ID of the target synchronizer
	// Must be a valid synchronizer id
	// Required
	Target string `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"`
	// contains filtered or unexported fields
}

type AssignedEvent struct {

	// The ID of the source synchronizer.
	// Must be a valid synchronizer id.
	// Required
	Source string `protobuf:"bytes,1,opt,name=source,proto3" json:"source,omitempty"`
	// The ID of the target synchronizer.
	// Must be a valid synchronizer id.
	// Required
	Target string `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	// The ID from the unassigned event.
	// For correlation capabilities.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ReassignmentId string `protobuf:"bytes,3,opt,name=reassignment_id,json=reassignmentId,proto3" json:"reassignment_id,omitempty"`
	// Party on whose behalf the assign command was executed.
	// Empty if the assignment happened offline via the repair service.
	// Must be a valid PartyIdString (as described in “value.proto“).
	// Optional
	Submitter string `protobuf:"bytes,4,opt,name=submitter,proto3" json:"submitter,omitempty"`
	// Each corresponding assigned and unassigned event has the same reassignment_counter. This strictly increases
	// with each unassign command for the same contract. Creation of the contract corresponds to reassignment_counter
	// equals zero.
	// Required
	ReassignmentCounter uint64 `protobuf:"varint,5,opt,name=reassignment_counter,json=reassignmentCounter,proto3" json:"reassignment_counter,omitempty"`
	// Required
	// The offset of this event refers to the offset of the assignment,
	// while the node_id is the index of within the batch.
	CreatedEvent *CreatedEvent `protobuf:"bytes,6,opt,name=created_event,json=createdEvent,proto3" json:"created_event,omitempty"`
	// contains filtered or unexported fields
}

type Command struct {

	// Types that are valid to be assigned 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) (grpc.ServerStreamingClient[CompletionStreamResponse], error)
}

type CommandCompletionServiceServer interface {
	// Subscribe to command completion events.
	CompletionStream(*CompletionStreamRequest, grpc.ServerStreamingServer[CompletionStreamResponse]) error
	// contains filtered or unexported methods
}

type CommandCompletionService_CompletionStreamClient = grpc.ServerStreamingClient[CompletionStreamResponse]

type CommandCompletionService_CompletionStreamServer = grpc.ServerStreamingServer[CompletionStreamResponse]

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) (*SubmitAndWaitResponse, 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 *SubmitAndWaitForTransactionRequest, opts ...grpc.CallOption) (*SubmitAndWaitForTransactionResponse, error)
	// Submits a single composite reassignment command, waits for its result, and returns the reassignment.
	// Propagates the gRPC error of failed submission.
	SubmitAndWaitForReassignment(ctx context.Context, in *SubmitAndWaitForReassignmentRequest, opts ...grpc.CallOption) (*SubmitAndWaitForReassignmentResponse, 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) (*SubmitAndWaitResponse, 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, *SubmitAndWaitForTransactionRequest) (*SubmitAndWaitForTransactionResponse, error)
	// Submits a single composite reassignment command, waits for its result, and returns the reassignment.
	// Propagates the gRPC error of failed submission.
	SubmitAndWaitForReassignment(context.Context, *SubmitAndWaitForReassignmentRequest) (*SubmitAndWaitForReassignmentResponse, error)
	// contains filtered or unexported methods
}

type CommandSubmissionServiceClient interface {
	// Submit a single composite command.
	Submit(ctx context.Context, in *SubmitRequest, opts ...grpc.CallOption) (*SubmitResponse, error)
	// Submit a single reassignment.
	SubmitReassignment(ctx context.Context, in *SubmitReassignmentRequest, opts ...grpc.CallOption) (*SubmitReassignmentResponse, error)
}

type CommandSubmissionServiceServer interface {
	// Submit a single composite command.
	Submit(context.Context, *SubmitRequest) (*SubmitResponse, error)
	// Submit a single reassignment.
	SubmitReassignment(context.Context, *SubmitReassignmentRequest) (*SubmitReassignmentResponse, 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=create_and_exercise,json=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=exercise_by_key,json=exerciseByKey,proto3,oneof"`
}

type Commands struct {

	// 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,1,opt,name=workflow_id,json=workflowId,proto3" json:"workflow_id,omitempty"`
	// Uniquely identifies the participant user that issued the command.
	// Must be a valid UserIdString (as described in “value.proto“).
	// Required unless authentication is used with a user token.
	// In that case, the token's user-id will be used for the request's user_id.
	UserId string `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// Uniquely identifies the command.
	// The triple (user_id, act_as, command_id) constitutes the change ID for the intended ledger change,
	// where 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,3,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// Individual elements of this atomic command. Must be non-empty.
	// Required
	Commands []*Command `protobuf:"bytes,4,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.
	//
	// Types that are valid to be assigned to DeduplicationPeriod:
	//
	//	*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,7,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,8,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.
	// Each element must be a valid PartyIdString (as described in “value.proto“).
	// Required, must be non-empty.
	ActAs []string `protobuf:"bytes,9,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,10,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,11,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,12,rep,name=disclosed_contracts,json=disclosedContracts,proto3" json:"disclosed_contracts,omitempty"`
	// Must be a valid synchronizer id
	// Optional
	SynchronizerId string `protobuf:"bytes,13,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// The package-id selection preference of the client for resolving
	// package names and interface instances in command submission and interpretation
	PackageIdSelectionPreference []string `` /* 150-byte string literal not displayed */
	// Fetches the contract keys into the caches to speed up the command processing.
	// Should only contain contract keys that are expected to be resolved during interpretation of the commands.
	// Keys of disclosed contracts do not need prefetching.
	//
	// Optional
	PrefetchContractKeys []*PrefetchContractKey `protobuf:"bytes,15,rep,name=prefetch_contract_keys,json=prefetchContractKeys,proto3" json:"prefetch_contract_keys,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.
	DeduplicationDuration *durationpb.Duration `protobuf:"bytes,5,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 absolute offset (positive integer) or participant begin (zero).
	DeduplicationOffset int64 `protobuf:"varint,6,opt,name=deduplication_offset,json=deduplicationOffset,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 update_id of the transaction or reassignment that resulted from the command with command_id.
	// Only set for successfully executed commands.
	// Must be a valid LedgerString (as described in “value.proto“).
	UpdateId string `protobuf:"bytes,3,opt,name=update_id,json=updateId,proto3" json:"update_id,omitempty"`
	// The user-id that was used for the submission, as described in “commands.proto“.
	// Must be a valid UserIdString (as described in “value.proto“).
	// Optional for historic completions where this data is not available.
	UserId string `protobuf:"bytes,4,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// The set of parties on whose behalf the commands were executed.
	// Contains the “act_as“ parties from “commands.proto“
	// filtered to the requesting parties in CompletionStreamRequest.
	// 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 valid to be assigned to DeduplicationPeriod:
	//
	//	*Completion_DeduplicationOffset
	//	*Completion_DeduplicationDuration
	DeduplicationPeriod isCompletion_DeduplicationPeriod `protobuf_oneof:"deduplication_period"`
	// Optional; ledger API trace context
	//
	// The trace context transported in this message corresponds to the trace context supplied
	// by the client application in a HTTP2 header of the original command submission.
	// We typically use a header to transfer this type of information. Here we use message
	// body, because it is used in gRPC streams which do not support per message headers.
	// This field will be populated with the trace context contained in the original submission.
	// If that was not provided, a unique ledger-api-server generated trace context will be used
	// instead.
	TraceContext *TraceContext `protobuf:"bytes,9,opt,name=trace_context,json=traceContext,proto3" json:"trace_context,omitempty"`
	// May be used in a subsequent CompletionStreamRequest to resume the consumption of this stream at a later time.
	// Required, must be a valid absolute offset (positive integer).
	Offset int64 `protobuf:"varint,10,opt,name=offset,proto3" json:"offset,omitempty"`
	// The synchronizer along with its record time.
	// The synchronizer id provided, in case of
	//
	// - successful/failed transactions: identifies the synchronizer of the transaction
	// - for successful/failed unassign commands: identifies the source synchronizer
	// - for successful/failed assign commands: identifies the target synchronizer
	//
	// Required
	SynchronizerTime *SynchronizerTime `protobuf:"bytes,11,opt,name=synchronizer_time,json=synchronizerTime,proto3" json:"synchronizer_time,omitempty"`
	// contains filtered or unexported fields
}

type CompletionStreamRequest struct {

	// Only completions of commands submitted with the same user_id will be visible in the stream.
	// Must be a valid UserIdString (as described in “value.proto“).
	// Required unless authentication is used with a user token.
	// In that case, the token's user-id will be used for the request's user_id.
	UserId string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// Non-empty list of parties whose data should be included.
	// The stream shows only completions of commands for which at least one of the “act_as“ parties is in the given set of parties.
	// Must be a valid PartyIdString (as described in “value.proto“).
	// Required
	Parties []string `protobuf:"bytes,2,rep,name=parties,proto3" json:"parties,omitempty"`
	// This optional field indicates the minimum offset for completions. This can be used to resume an earlier completion stream.
	// If not set the ledger uses the ledger begin offset instead.
	// If specified, it must be a valid absolute offset (positive integer) or zero (ledger begin offset).
	// If the ledger has been pruned, this parameter must be specified and greater than the pruning offset.
	BeginExclusive int64 `protobuf:"varint,3,opt,name=begin_exclusive,json=beginExclusive,proto3" json:"begin_exclusive,omitempty"`
	// contains filtered or unexported fields
}

type CompletionStreamResponse struct {

	// Types that are valid to be assigned to CompletionResponse:
	//
	//	*CompletionStreamResponse_Completion
	//	*CompletionStreamResponse_OffsetCheckpoint
	CompletionResponse isCompletionStreamResponse_CompletionResponse `protobuf_oneof:"completion_response"`
	// contains filtered or unexported fields
}

type CompletionStreamResponse_Completion struct {
	Completion *Completion `protobuf:"bytes,1,opt,name=completion,proto3,oneof"`
}

type CompletionStreamResponse_OffsetCheckpoint struct {
	OffsetCheckpoint *OffsetCheckpoint `protobuf:"bytes,2,opt,name=offset_checkpoint,json=offsetCheckpoint,proto3,oneof"`
}

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,8,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 absolute offset (positive integer) or participant begin (zero).
	DeduplicationOffset int64 `protobuf:"varint,7,opt,name=deduplication_offset,json=deduplicationOffset,proto3,oneof"`
}

type CreateAndExerciseCommand struct {

	// The template of the contract the client wants to create.
	// Both package-name and package-id reference identifier formats for the template-id are supported.
	// Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4.
	//
	// 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.
	// Both package-name and package-id reference identifier formats for the template-id are supported.
	// Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4.
	//
	// 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 Created struct {

	// Required
	// The event as it appeared in the context of its original update (i.e. daml transaction or
	// reassignment) on this participant node. You can use its offset and node_id to find the
	// corresponding update and the node within it.
	CreatedEvent *CreatedEvent `protobuf:"bytes,1,opt,name=created_event,json=createdEvent,proto3" json:"created_event,omitempty"`
	// The synchronizer which sequenced the creation of the contract
	// Required
	SynchronizerId string `protobuf:"bytes,2,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// contains filtered or unexported fields
}

type CreatedEvent struct {

	// The offset of origin, which has contextual meaning, please see description at messages that include a CreatedEvent.
	// Offsets are managed by the participant nodes.
	// Transactions can thus NOT be assumed to have the same offsets on different participant nodes.
	// Required, it is a valid absolute offset (positive integer)
	Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// The position of this event in the originating transaction or reassignment.
	// The origin has contextual meaning, please see description at messages that include a CreatedEvent.
	// Node IDs are not necessarily equal across participants,
	// as these may see different projections/parts of transactions.
	// Required, must be valid node ID (non-negative integer)
	NodeId int32 `protobuf:"varint,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// The ID of the created contract.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,3,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// The template of the created contract.
	// The identifier uses the package-id reference format.
	//
	// Required
	TemplateId *Identifier `protobuf:"bytes,4,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 “template_id“ defines a contract key.
	// Optional
	ContractKey *Value `protobuf:"bytes,5,opt,name=contract_key,json=contractKey,proto3" json:"contract_key,omitempty"`
	// The arguments that have been used to create the contract.
	//
	// Required
	CreateArguments *Record `protobuf:"bytes,6,opt,name=create_arguments,json=createArguments,proto3" json:"create_arguments,omitempty"`
	// Opaque representation of contract create event payload intended for forwarding
	// to an API server as a contract disclosed as part of a command
	// submission.
	// Optional
	CreatedEventBlob []byte `protobuf:"bytes,7,opt,name=created_event_blob,json=createdEventBlob,proto3" json:"created_event_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,8,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 or ledger-effects transaction, this will include all
	// the parties specified in the “TransactionFilter“ that are witnesses  of the event
	// (the stakeholders of the contract and all informees of all the ancestors
	// of this create action that this participant knows about).
	// If served as part of a ACS delta transaction those will
	// be limited to all parties specified in the “TransactionFilter“ that
	// are stakeholders of the contract (i.e. either signatories or observers).
	// If the “CreatedEvent“ is returned as part of an AssignedEvent,
	// ActiveContract or IncompleteUnassigned (so the event is related to
	// an assignment or unassignment): this will include all parties of the
	// “TransactionFilter“ that are stakeholders of the contract.
	//
	// The behavior of reading create events visible to parties not hosted
	// on the participant node serving the Ledger API is undefined. Concretely,
	// there is neither a guarantee that the participant node will serve all their
	// create events on the ACS stream, nor is there a guarantee that matching archive
	// events are delivered for such create events.
	//
	// For most clients this is not a problem, as they only read events for parties
	// that are hosted on the participant node. If you need to read events
	// for parties that may not be hosted at all times on the participant node,
	// subscribe to the “TopologyEvent“s for that party by setting a corresponding
	// “UpdateFormat“.  Using these events, query the ACS as-of an offset where the
	// party is hosted on the participant node, and ignore create events at offsets
	// where the party is not hosted on the participant node.
	// Required
	WitnessParties []string `protobuf:"bytes,9,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,10,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,11,rep,name=observers,proto3" json:"observers,omitempty"`
	// Ledger effective time of the transaction that created the contract.
	// Required
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	// The package name of the created contract.
	// Required
	PackageName string `protobuf:"bytes,13,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	// Whether this event would be part of respective ACS_DELTA shaped stream,
	// and should therefore considered when tracking contract activeness on the client-side.
	// Required
	AcsDelta bool `protobuf:"varint,14,opt,name=acs_delta,json=acsDelta,proto3" json:"acs_delta,omitempty"`
	// A package-id present in the participant package store that typechecks the contract's argument.
	// This may differ from the package-id of the template used to create the contract.
	// For contracts created before Canton 3.4, this field matches the contract's creation package-id.
	//
	// NOTE: Experimental, server internal concept, not for client consumption. Subject to change without notice.
	//
	// Required
	RepresentativePackageId string `` /* 133-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CryptoKeyFormat int32

type CumulativeFilter struct {

	// Types that are valid to be assigned to IdentifierFilter:
	//
	//	*CumulativeFilter_WildcardFilter
	//	*CumulativeFilter_InterfaceFilter
	//	*CumulativeFilter_TemplateFilter
	IdentifierFilter isCumulativeFilter_IdentifierFilter `protobuf_oneof:"identifier_filter"`
	// contains filtered or unexported fields
}

type CumulativeFilter_InterfaceFilter struct {
	// Include an “InterfaceView“ for every “InterfaceFilter“ matching a contract.
	// The “InterfaceFilter“ instances MUST each use a unique “interface_id“.
	// Optional
	InterfaceFilter *InterfaceFilter `protobuf:"bytes,2,opt,name=interface_filter,json=interfaceFilter,proto3,oneof"`
}

type CumulativeFilter_TemplateFilter struct {
	// A template for which the data will be included in the
	// “create_arguments“ of a matching “CreatedEvent“.
	// If a contract is simultaneously selected by a template filter and one or more interface filters,
	// the corresponding “include_created_event_blob“ are consolidated using an OR operation.
	// Optional
	TemplateFilter *TemplateFilter `protobuf:"bytes,3,opt,name=template_filter,json=templateFilter,proto3,oneof"`
}

type CumulativeFilter_WildcardFilter struct {
	// A wildcard filter that matches all templates
	// Optional
	WildcardFilter *WildcardFilter `protobuf:"bytes,1,opt,name=wildcard_filter,json=wildcardFilter,proto3,oneof"`
}

type DisclosedContract struct {

	// The template id of the contract.
	// The identifier uses the package-id reference format.
	//
	// If provided, used to validate the template id of the contract serialized in the created_event_blob.
	// Optional
	TemplateId *Identifier `protobuf:"bytes,1,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The contract id
	//
	// If provided, used to validate the contract id of the contract serialized in the created_event_blob.
	// Optional
	ContractId string `protobuf:"bytes,2,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// Opaque byte string containing the complete payload required by the Daml engine
	// to reconstruct a contract not known to the receiving participant.
	// Required
	CreatedEventBlob []byte `protobuf:"bytes,3,opt,name=created_event_blob,json=createdEventBlob,proto3" json:"created_event_blob,omitempty"`
	// The ID of the synchronizer where the contract is currently assigned
	// Optional
	SynchronizerId string `protobuf:"bytes,4,opt,name=synchronizer_id,json=synchronizerId,proto3" json:"synchronizer_id,omitempty"`
	// contains filtered or unexported fields
}

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 valid to be assigned to Event:
	//
	//	*Event_Created
	//	*Event_Archived
	//	*Event_Exercised
	Event isEvent_Event `protobuf_oneof:"event"`
	// contains filtered or unexported fields
}

type EventFormat struct {

	// Each key must be a valid PartyIdString (as described in “value.proto“).
	// The interpretation of the filter depends on the transaction-shape being filtered:
	//
	//  1. For **ledger-effects** create and exercise events are returned, for which the witnesses include at least one of
	//     the listed parties and match the per-party filter.
	//  2. For **transaction and active-contract-set streams** create and archive events are returned for all contracts whose
	//     stakeholders include at least one of the listed parties and match the per-party filter.
	//
	// Optional
	FiltersByParty map[string]*Filters `` /* 179-byte string literal not displayed */
	// Wildcard filters that apply to all the parties existing on the participant. The interpretation of the filters is the same
	// with the per-party filter as described above.
	// Optional
	FiltersForAnyParty *Filters `protobuf:"bytes,2,opt,name=filters_for_any_party,json=filtersForAnyParty,proto3" json:"filters_for_any_party,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 EventQueryServiceClient interface {
	// Get the create and the consuming exercise event for the contract with the provided ID.
	// No events will be returned for contracts that have been pruned because they
	// have already been archived before the latest pruning offset.
	// If the contract cannot be found for the request, or all the contract-events are filtered, a CONTRACT_EVENTS_NOT_FOUND error will be raised.
	GetEventsByContractId(ctx context.Context, in *GetEventsByContractIdRequest, opts ...grpc.CallOption) (*GetEventsByContractIdResponse, error)
}

type EventQueryServiceServer interface {
	// Get the create and the consuming exercise event for the contract with the provided ID.
	// No events will be returned for contracts that have been pruned because they
	// have already been archived before the latest pruning offset.
	// If the contract cannot be found for the request, or all the contract-events are filtered, a CONTRACT_EVENTS_NOT_FOUND error will be raised.
	GetEventsByContractId(context.Context, *GetEventsByContractIdRequest) (*GetEventsByContractIdResponse, error)
	// contains filtered or unexported methods
}

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

type Event_Created struct {
	// The event as it appeared in the context of its original daml transaction on this participant node.
	// In particular, the offset, node_id pair of the daml transaction are preserved.
	Created *CreatedEvent `protobuf:"bytes,1,opt,name=created,proto3,oneof"`
}

type Event_Exercised struct {
	Exercised *ExercisedEvent `protobuf:"bytes,3,opt,name=exercised,proto3,oneof"`
}

type ExerciseByKeyCommand struct {

	// The template of contract the client wants to exercise.
	// Both package-name and package-id reference identifier formats for the template-id are supported.
	// Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4.
	//
	// 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 or interface of the contract the client wants to exercise.
	// Both package-name and package-id reference identifier formats for the template-id are supported.
	// Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4.
	// To exercise a choice on an interface, specify the interface identifier in the template_id field.
	//
	// 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 offset of origin.
	// Offsets are managed by the participant nodes.
	// Transactions can thus NOT be assumed to have the same offsets on different participant nodes.
	// Required, it is a valid absolute offset (positive integer)
	Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// The position of this event in the originating transaction or reassignment.
	// Node IDs are not necessarily equal across participants,
	// as these may see different projections/parts of transactions.
	// Required, must be valid node ID (non-negative integer)
	NodeId int32 `protobuf:"varint,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	// The ID of the target contract.
	// Must be a valid LedgerString (as described in “value.proto“).
	// Required
	ContractId string `protobuf:"bytes,3,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty"`
	// Identifies the template that defines the executed choice.
	// This template's package-id may differ from the target contract's package-id
	// if the target contract has been upgraded or downgraded.
	//
	// The identifier uses the package-id reference format.
	//
	// Required
	TemplateId *Identifier `protobuf:"bytes,4,opt,name=template_id,json=templateId,proto3" json:"template_id,omitempty"`
	// The interface where the choice is defined, if inherited.
	// If defined, the identifier uses the package-id reference format.
	//
	// Optional
	InterfaceId *Identifier `protobuf:"bytes,5,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,6,opt,name=choice,proto3" json:"choice,omitempty"`
	// The argument of the exercised choice.
	// Required
	ChoiceArgument *Value `protobuf:"bytes,7,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,8,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,9,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,
	// the actors and all informees of all the ancestors of this event this
	// participant knows about.
	// If not consuming, the witnesses are the union of the signatories,
	// the actors and all informees of all the ancestors of this event this
	// participant knows about.
	// In both cases the witnesses are limited to the querying parties, or not
	// limited in case anyParty filters are used.
	// Note that the actors might not necessarily be observers
	// and thus stakeholders. 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"`
	// Specifies the upper boundary of the node ids of the events in the same transaction that appeared as a result of
	// this “ExercisedEvent“. This allows unambiguous identification of all the members of the subtree rooted at this
	// node. A full subtree can be constructed when all descendant nodes are present in the stream. If nodes are heavily
	// filtered, it is only possible to determine if a node is in a consequent subtree or not.
	// Required
	LastDescendantNodeId int32 `` /* 127-byte string literal not displayed */
	// The result of exercising the choice.
	// Required
	ExerciseResult *Value `protobuf:"bytes,12,opt,name=exercise_result,json=exerciseResult,proto3" json:"exercise_result,omitempty"`
	// The package name of the contract.
	// Required
	PackageName string `protobuf:"bytes,13,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	// If the event is consuming, the interfaces implemented by the target template that have been
	// matched from the interface filter query.
	// Populated only in case interface filters with include_interface_view set.
	//
	// The identifier uses the package-id reference format.
	//
	// Optional
	ImplementedInterfaces []*Identifier `protobuf:"bytes,14,rep,name=implemented_interfaces,json=implementedInterfaces,proto3" json:"implemented_interfaces,omitempty"`
	// Whether this event would be part of respective ACS_DELTA shaped stream,
	// and should therefore considered when tracking contract activeness on the client-side.
	// Required
	AcsDelta bool `protobuf:"varint,15,opt,name=acs_delta,json=acsDelta,proto3" json:"acs_delta,omitempty"`
	// contains filtered or unexported fields
}

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

type ExperimentalFeatures struct {
	StaticTime               *ExperimentalStaticTime               `protobuf:"bytes,1,opt,name=static_time,json=staticTime,proto3" json:"static_time,omitempty"`
	CommandInspectionService *ExperimentalCommandInspectionService `` /* 135-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ExperimentalPartyTopologyEvents struct {
	Supported bool `protobuf:"varint,1,opt,name=supported,proto3" json:"supported,omitempty"`
	// 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 FeaturesDescriptor struct {

	// 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"`
	// 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"`
	// If set, then the Ledger API server supports party management configurability.
	// It is recommended that clients query this field to gracefully adjust their behavior to
	// maximum party page size.
	PartyManagement *PartyManagementFeature `protobuf:"bytes,3,opt,name=party_management,json=partyManagement,proto3" json:"party_management,omitempty"`
	// It contains the timeouts related to the periodic offset checkpoint emission
	OffsetCheckpoint *OffsetCheckpointFeature `protobuf:"bytes,4,opt,name=offset_checkpoint,json=offsetCheckpoint,proto3" json:"offset_checkpoint,omitempty"`
	// If set, then the Ledger API server supports package listing
	// configurability. It is recommended that clients query this field to
	// gracefully adjust their behavior to maximum package listing page size.
	PackageFeature *PackageFeature `protobuf:"bytes,5,opt,name=package_feature,json=packageFeature,proto3" json:"package_feature,omitempty"`
	// contains filtered or unexported fields
}

type Filters struct {

	// Every filter in the cumulative list expands the scope of the resulting stream. Each interface,
	// template or wildcard filter means additional events that will match the query.
	// The impact of include_interface_view and include_created_event_blob fields in the filters will
	// also be accumulated.
	// A template or an interface SHOULD NOT appear twice in the accumulative field.
	// A wildcard filter SHOULD NOT be defined more than once in the accumulative field.
	// Optional, if no “CumulativeFilter“ defined, the default of a single “WildcardFilter“ with
	// include_created_event_blob unset is used.
	Cumulative []*CumulativeFilter `protobuf:"bytes,1,rep,name=cumulative,proto3" json:"cumulative,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
}