model

type ActiveContract struct {
	CreatedEvent        *CreatedEvent
	SynchronizerID      string
	ReassignmentCounter uint64
}

type ActiveContractEntry struct {
	ActiveContract *ActiveContract
}

type AddTransactionsRequest struct {
	Transactions          []*SignedTopologyTransaction
	ForceChanges          []ForceFlag
	Store                 *StoreID
	WaitToBecomeEffective *time.Duration
}

type AddTransactionsResponse struct{}

type ArchivedEvent struct {
	Offset                int64
	NodeID                int32
	ContractID            string
	TemplateID            string
	WitnessParties        []string
	PackageName           string
	ImplementedInterfaces []string
}

type AssignedEvent struct {
	Source              string
	Target              string
	UnassignID          string
	Submitter           string
	ReassignmentCounter uint64
	CreatedEvent        *CreatedEvent
}

type AuthorizeRequest struct {
	Proposal              *TopologyTransactionProposal
	TransactionHash       string
	MustFullyAuthorize    bool
	ForceChanges          []ForceFlag
	SignedBy              []string
	Store                 *StoreID
	WaitToBecomeEffective *time.Duration
}

type AuthorizeResponse struct {
	Transaction *SignedTopologyTransaction
}

type BaseQuery struct {
	Store           *StoreID
	Proposals       bool
	TimeQuery       *TimeQuery
	Operation       Operation
	FilterSignedKey string
	ProtocolVersion *int32
}

type BaseResult struct {
	Store                *StoreID
	Sequenced            *time.Time
	ValidFrom            *time.Time
	ValidUntil           *time.Time
	Operation            Operation
	TransactionHash      []byte
	Serial               int32
	SignedByFingerprints []string
}

type CanActAs struct {
	Party string
}

type CanReadAs struct {
	Party string
}

type Command struct {
	Command CommandType
}

type CommandState int

type CommandStatus struct {
	Started   *time.Time
	Completed *time.Time
	State     CommandState
}

type CommandType interface {
	// contains filtered or unexported methods
}

type Commands struct {
	WorkflowID          string
	UserID              string
	CommandID           string
	Commands            []*Command
	DeduplicationPeriod DeduplicationPeriod
	MinLedgerTimeAbs    *time.Time
	MinLedgerTimeRel    *time.Duration
	ActAs               []string
	ReadAs              []string
	SubmissionID        string
	DisclosedContracts  []*DisclosedContract
}

type Completion struct {
	CommandID     string
	Status        Status
	UpdateID      string
	TransactionID string
	SubmissionID  string
	CompletedAt   *time.Time
	Offset        int64
}

type CompletionResponse interface {
	// contains filtered or unexported methods
}

type CompletionStreamRequest struct {
	UserID         string
	Parties        []string
	BeginExclusive int64
}

type CompletionStreamResponse struct {
	Response CompletionResponse
}

type ConnectedSynchronizer struct {
	SynchronizerID        string
	ParticipantPermission ParticipantPermission
}

type ContractEntry interface {
	// contains filtered or unexported methods
}

type CreateCommand struct {
	TemplateID string
	Arguments  map[string]interface{}
}

type CreateTemporaryTopologyStoreRequest struct {
	Name            string
	ProtocolVersion uint32
}

type CreateTemporaryTopologyStoreResponse struct {
	StoreID *StoreID
}

type CreatedEvent struct {
	Offset           int64
	NodeID           int32
	ContractID       string
	TemplateID       string
	ContractKey      interface{}
	CreateArguments  interface{}
	CreatedEventBlob []byte
	InterfaceViews   []*InterfaceView
	WitnessParties   []string
	Signatories      []string
	Observers        []string
	CreatedAt        *time.Time
	PackageName      string
}

type DeduplicationDuration struct {
	Duration time.Duration
}

type DeduplicationOffset struct {
	Offset int64
}

type DeduplicationPeriod interface {
	// contains filtered or unexported methods
}

type DisclosedContract struct {
	TemplateID       string
	ContractID       string
	CreatedEventBlob []byte
	SynchronizerID   string
}

type DropTemporaryTopologyStoreRequest struct {
	StoreID *StoreID
}

type DropTemporaryTopologyStoreResponse struct{}

type Event struct {
	Created   *CreatedEvent
	Archived  *ArchivedEvent
	Exercised *ExercisedEvent
}

type EventFormat struct {
	FiltersByParty     map[string]*Filters
	FiltersForAnyParty *Filters
	Verbose            bool
}

type ExecuteSubmissionRequest struct {
	PreparedTransaction  []byte
	PartySignatures      []*SinglePartySignatures
	DeduplicationPeriod  DeduplicationPeriod
	SubmissionID         string
	UserID               string
	HashingSchemeVersion HashingSchemeVersion
	MinLedgerTime        *MinLedgerTime
}

type ExecuteSubmissionResponse struct{}

type ExerciseByKeyCommand struct {
	TemplateID string
	Key        map[string]interface{}
	Choice     string
	Arguments  map[string]interface{}
}

type ExerciseCommand struct {
	ContractID string
	TemplateID string
	Choice     string
	Arguments  map[string]interface{}
}

type ExercisedEvent struct {
	Offset                int64
	NodeID                int32
	ContractID            string
	TemplateID            string
	InterfaceID           string
	Choice                string
	ChoiceArgument        interface{}
	ActingParties         []string
	Consuming             bool
	WitnessParties        []string
	LastDescendantNodeID  int32
	ExerciseResult        interface{}
	PackageName           string
	ImplementedInterfaces []string
}

type FeaturesDescriptor struct {
	UserManagement   bool
	PartyManagement  bool
	OffsetCheckpoint bool
}

type FilterTargetKeyOrFingerprint struct {
	Fingerprint string
}

type Filters struct {
	Inclusive *InclusiveFilters
}

type ForceFlag int32

type GenerateTransactionProposal struct {
	Operation Operation
	Serial    uint32
	Mapping   TopologyMapping
	Store     *StoreID
}

type GenerateTransactionsRequest struct {
	Proposals []*GenerateTransactionProposal
}

type GenerateTransactionsResponse struct {
	GeneratedTransactions []*GeneratedTransaction
}

type GeneratedTransaction struct {
	SerializedTransaction []byte
	TransactionHash       []byte
}

type GetActiveContractsRequest struct {
	ActiveAtOffset int64
	EventFormat    *EventFormat
}

type GetActiveContractsResponse struct {
	WorkflowID    string
	ContractEntry ContractEntry
}

type GetConnectedSynchronizersRequest struct{}

type GetConnectedSynchronizersResponse struct {
	ConnectedSynchronizers []*ConnectedSynchronizer
}

type GetEventsByContractIDRequest struct {
	ContractID  string
	EventFormat *EventFormat
}

type GetEventsByContractIDResponse struct {
	CreateEvent  *CreatedEvent
	ArchiveEvent *ArchivedEvent
}

type GetLatestPrunedOffsetsRequest struct{}

type GetLatestPrunedOffsetsResponse struct {
	ParticipantPrunedUpToInclusive          int64
	AllDivulgedContractsPrunedUpToInclusive int64
}

type GetLedgerAPIVersionRequest struct{}

type GetLedgerAPIVersionResponse struct {
	Version  string
	Features *FeaturesDescriptor
}

type GetLedgerEndRequest struct{}

type GetLedgerEndResponse struct {
	Offset int64
}

type GetPackageRequest struct {
	PackageID string
}

type GetPackageResponse struct {
	ArchivePayload []byte
	HashFunction   HashFunction
	Hash           string
}

type GetPackageStatusRequest struct {
	PackageID string
}

type GetPackageStatusResponse struct {
	PackageStatus PackageStatus
}

type GetPreferredPackageVersionRequest struct {
	Parties        []string
	PackageName    string
	SynchronizerID string
	VettingValidAt *time.Time
}

type GetPreferredPackageVersionResponse struct {
	PackageReference *PackageReference
	SynchronizerID   string
}

type GetTimeRequest struct{}

type GetTimeResponse struct {
	CurrentTime time.Time
}

type GetTransactionByIDRequest struct {
	UpdateID          string
	RequestingParties []string
	UpdateFormat      *EventFormat
}

type GetTransactionByOffsetRequest struct {
	Offset            int64
	RequestingParties []string
	UpdateFormat      *EventFormat
}

type GetTransactionResponse struct {
	Transaction *Transaction
}

type GetUpdateByIDRequest struct {
	UpdateID     string
	UpdateFormat *EventFormat
}

type GetUpdateResponse struct {
	Transaction *Transaction
}

type GetUpdatesRequest struct {
	BeginExclusive int64
	EndInclusive   *int64
	Filter         *TransactionFilter
	UpdateFormat   *EventFormat
	Verbose        bool
}

type GetUpdatesResponse struct {
	Update *Update
}

type HashFunction int32

type HashingSchemeVersion int32

type HostingParticipant struct {
	ParticipantUID string
	Permission     ParticipantPermission
}

type IdentityProviderAdmin struct{}

type IdentityProviderConfig struct {
	IdentityProviderID string
	IsDeactivated      bool
	Issuer             string
	JwksURL            string
	Audience           string
}

type ImportTopologySnapshotRequest struct {
	TopologySnapshot      []byte
	Store                 *StoreID
	WaitToBecomeEffective *time.Duration
}

type ImportTopologySnapshotResponse struct{}

type InclusiveFilters struct {
	TemplateFilters  []*TemplateFilter
	InterfaceFilters []*InterfaceFilter
}

type IncompleteAssigned struct {
	AssignedEvent *AssignedEvent
}

type IncompleteAssignedEntry struct {
	IncompleteAssigned *IncompleteAssigned
}

type IncompleteUnassigned struct {
	CreatedEvent    *CreatedEvent
	UnassignedEvent *UnassignedEvent
}

type IncompleteUnassignedEntry struct {
	IncompleteUnassigned *IncompleteUnassigned
}

type InterfaceFilter struct {
	InterfaceID             string
	IncludeInterfaceView    bool
	IncludeCreatedEventBlob bool
}

type InterfaceView struct {
	InterfaceID string
	ViewStatus  *ViewStatus
	ViewValue   interface{}
}

type ListKnownPartiesResponse struct {
	PartyDetails  []*PartyDetails
	NextPageToken string
}

type ListNamespaceDelegationRequest struct {
	BaseQuery                  *BaseQuery
	FilterNamespace            string
	FilterTargetKeyFingerprint string
}

type ListNamespaceDelegationResponse struct {
	Results []*NamespaceDelegationResult
}

type ListPackagesRequest struct{}

type ListPackagesResponse struct {
	PackageIDs []string
}

type ListPartyToKeyMappingRequest struct {
	BaseQuery   *BaseQuery
	FilterParty string
}

type ListPartyToKeyMappingResponse struct {
	Results []*PartyToKeyMappingResult
}

type ListPartyToParticipantRequest struct {
	BaseQuery         *BaseQuery
	FilterParty       string
	FilterParticipant string
}

type ListPartyToParticipantResponse struct {
	Results []*PartyToParticipantResult
}

type MinLedgerTime struct {
	Time MinLedgerTimeValue
}

type MinLedgerTimeAbs struct {
	Time time.Time
}

type MinLedgerTimeRel struct {
	Duration time.Duration
}

type MinLedgerTimeValue interface {
	// contains filtered or unexported methods
}

type MultiTransactionSignatures struct {
	TransactionHashes [][]byte
	Signatures        []TopologyTransactionSignature
}

type NamespaceDelegationMapping struct {
	Namespace        string
	TargetKey        PublicKey
	IsRootDelegation bool
}

type NamespaceDelegationResult struct {
	Context *BaseResult
	Item    *NamespaceDelegationMapping
}

type OffsetCheckpoint struct {
	Offset int64
}

type Operation int32

type PackageDetails struct {
	PackageID   string
	PackageSize uint64
	KnownSince  *time.Time
	Name        string
	Version     string
}

type PackageReference struct {
	PackageID      string
	PackageName    string
	PackageVersion string
}

type PackageStatus int32

type ParticipantAdmin struct{}

type ParticipantPermission int32

type PartyDetails struct {
	Party              string
	IsLocal            bool
	LocalMetadata      map[string]string
	IdentityProviderID string
}

type PartyToKeyMapping struct {
	Party       string
	Threshold   uint32
	SigningKeys []PublicKey
}

type PartyToKeyMappingResult struct {
	Context *BaseResult
	Item    *PartyToKeyMapping
}

type PartyToParticipantMapping struct {
	Party        string
	Threshold    uint32
	Participants []HostingParticipant
}

type PartyToParticipantResult struct {
	Context *BaseResult
	Item    *PartyToParticipantMapping
}

type PrefetchContractKey struct {
	TemplateID  string
	ContractKey map[string]interface{}
}

type PrepareSubmissionRequest struct {
	UserID                       string
	CommandID                    string
	Commands                     []*Command
	MinLedgerTime                *MinLedgerTime
	ActAs                        []string
	ReadAs                       []string
	DisclosedContracts           []*DisclosedContract
	SynchronizerID               string
	PackageIDSelectionPreference []string
	VerboseHashing               bool
	PrefetchContractKeys         []*PrefetchContractKey
}

type PrepareSubmissionResponse struct {
	PreparedTransaction     []byte
	PreparedTransactionHash []byte
	HashingSchemeVersion    HashingSchemeVersion
	HashingDetails          string
}

type PruneRequest struct {
	PruneUpTo                 int64
	SubmissionID              string
	PruneAllDivulgedContracts bool
}

type PublicKey struct {
	Format  int32
	Key     []byte
	ID      string
	Scheme  int32
	KeySpec int32
	Usage   []int32
}

type Reassignment struct {
	UpdateID    string
	Offset      int64
	UnassignID  string
	Source      string
	Target      string
	Counter     int64
	SubmittedAt *time.Time
	Unassigned  *time.Time
	Reassigned  *time.Time
}

type ResultStatus int32

type Right struct {
	Type RightType
}

type RightType interface {
	// contains filtered or unexported methods
}

type SDKVersionMismatchError struct {
	NodeVersion     string
	ContractVersion string
}

type SetTimeRequest struct {
	CurrentTime time.Time
	NewTime     time.Time
}

type SetTimeResponse struct{}

type SignTransactionsRequest struct {
	Transactions []*SignedTopologyTransaction
	SignedBy     []string
	Store        *StoreID
	ForceFlags   []ForceFlag
}

type SignTransactionsResponse struct {
	Transactions []*SignedTopologyTransaction
}

type Signature struct {
	Format               SignatureFormat
	Signature            []byte
	SignedBy             string
	SigningAlgorithmSpec SigningAlgorithmSpec
}

type SignatureFormat int32

type SignedTopologyTransaction struct {
	Transaction                []byte
	Signatures                 []TopologyTransactionSignature
	MultiTransactionSignatures []*MultiTransactionSignatures
	Proposal                   bool
}

type SignedTransaction struct {
	Transaction []byte
	Signatures  []Signature
}

type SigningAlgorithmSpec int32

type SigningKeyScheme int32

type SigningKeySpec int32

type SigningKeyUsage int32

type SinglePartySignatures struct {
	Party      string
	Signatures []*Signature
}

type Status interface {
	// contains filtered or unexported methods
}

type StatusError struct {
	Code    int32
	Message string
}

type StatusOK struct{}

type StoreID struct {
	Value string
}

type SubmitAndWaitForTransactionResponse struct {
	UpdateID         string
	CompletionOffset int64
	Transaction      *Transaction
}

type SubmitAndWaitRequest struct {
	Commands *Commands
}

type SubmitAndWaitResponse struct {
	UpdateID         string
	CompletionOffset int64
}

type SubmitRequest struct {
	Commands *Commands
}

type SubmitResponse struct{}

type TemplateFilter struct {
	TemplateID              string
	IncludeCreatedEventBlob bool
}

type TimeQuery struct {
	Serial *int64
	Range  *TimeRange
}

type TimeRange struct {
	From  *time.Time
	Until *time.Time
}

type TopologyMapping interface {
	// contains filtered or unexported methods
}

type TopologyTransactionProposal struct {
	Operation Operation
	Mapping   TopologyMapping
	Serial    uint32
}

type TopologyTransactionResult struct {
	Transaction  *SignedTopologyTransaction
	Status       ResultStatus
	ErrorMessage string
}

type TopologyTransactionSignature struct {
	SignedBy        string
	Signature       []byte
	SignatureFormat int32
}

type Transaction struct {
	UpdateID    string
	CommandID   string
	WorkflowID  string
	EffectiveAt *time.Time
	Events      []*Event
	Offset      int64
}

type TransactionFilter struct {
	FiltersByParty map[string]*Filters
}

type UnassignedEvent struct {
	UnassignID            string
	ContractID            string
	TemplateID            string
	Source                string
	Target                string
	Submitter             string
	ReassignmentCounter   uint64
	AssignmentExclusivity *time.Time
	WitnessParties        []string
	PackageName           string
	Offset                int64
}

type Update struct {
	Transaction      *Transaction
	Reassignment     *Reassignment
	OffsetCheckpoint *OffsetCheckpoint
}

type UpdateMask struct {
	Paths []string
}

type User struct {
	ID                 string
	PrimaryParty       string
	IsDeactivated      bool
	Metadata           map[string]string
	IdentityProviderID string
}

type ViewStatus struct {
	Code    int32
	Message string
}