@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/com/daml/ledger/api/v2/interactive/interactive_submission_service.d.ts

@@ -0,0 +1,877 @@
+import { ServiceType } from '@protobuf-ts/runtime-rpc';
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { IBinaryWriter } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { IBinaryReader } from '@protobuf-ts/runtime';
+import type { PartialMessage } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+import { PackageReference } from '../package_reference.js';
+import { Node } from './transaction/v1/interactive_submission_data.js';
+import { Create } from './transaction/v1/interactive_submission_data.js';
+import { Value } from '../value.js';
+import { GlobalKey } from './interactive_submission_common_data.js';
+import { Timestamp } from '../../../../../../google/protobuf/timestamp.js';
+import { Duration } from '../../../../../../google/protobuf/duration.js';
+import { PrefetchContractKey } from '../commands.js';
+import { DisclosedContract } from '../commands.js';
+import { Command } from '../commands.js';
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.PrepareSubmissionRequest
+ */
+export interface PrepareSubmissionRequest {
+    /**
+     * Uniquely identifies the participant user that prepares the transaction.
+     * 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.
+     *
+     * @generated from protobuf field: string user_id = 1
+     */
+    userId: string;
+    /**
+     * 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
+     *
+     * @generated from protobuf field: string command_id = 2
+     */
+    commandId: string;
+    /**
+     * Individual elements of this atomic command. Must be non-empty.
+     * Required
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.Command commands = 3
+     */
+    commands: Command[];
+    /**
+     * Optional
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.MinLedgerTime min_ledger_time = 4
+     */
+    minLedgerTime?: MinLedgerTime;
+    /**
+     * Set of parties on whose behalf the command should be executed, if submitted.
+     * If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request
+     * to **read** (not act) on behalf of each of the given parties. This is because this RPC merely prepares a transaction
+     * and does not execute it. Therefore read authorization is sufficient even for actAs parties.
+     * Note: This may change, and more specific authorization scope may be introduced in the future.
+     * Each element must be a valid PartyIdString (as described in ``value.proto``).
+     * Required, must be non-empty.
+     *
+     * @generated from protobuf field: repeated string act_as = 5
+     */
+    actAs: string[];
+    /**
+     * 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 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
+     *
+     * @generated from protobuf field: repeated string read_as = 6
+     */
+    readAs: string[];
+    /**
+     * Additional contracts used to resolve contract & contract key lookups.
+     * Optional
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.DisclosedContract disclosed_contracts = 7
+     */
+    disclosedContracts: DisclosedContract[];
+    /**
+     * Must be a valid synchronizer id
+     * Required
+     *
+     * @generated from protobuf field: string synchronizer_id = 8
+     */
+    synchronizerId: string;
+    /**
+     * The package-id selection preference of the client for resolving
+     * package names and interface instances in command submission and interpretation
+     *
+     * @generated from protobuf field: repeated string package_id_selection_preference = 9
+     */
+    packageIdSelectionPreference: string[];
+    /**
+     * When true, the response will contain additional details on how the transaction was encoded and hashed
+     * This can be useful for troubleshooting of hash mismatches. Should only be used for debugging.
+     *
+     * @generated from protobuf field: bool verbose_hashing = 10
+     */
+    verboseHashing: boolean;
+    /**
+     * 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
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.PrefetchContractKey prefetch_contract_keys = 15
+     */
+    prefetchContractKeys: PrefetchContractKey[];
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.PrepareSubmissionResponse
+ */
+export interface PrepareSubmissionResponse {
+    /**
+     * The interpreted transaction, it represents the ledger changes necessary to execute the commands specified in the request.
+     * Clients MUST display the content of the transaction to the user for them to validate before signing the hash if the preparing participant is not trusted.
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.PreparedTransaction prepared_transaction = 1
+     */
+    preparedTransaction?: PreparedTransaction;
+    /**
+     * Hash of the transaction, this is what needs to be signed by the party to authorize the transaction.
+     * Only provided for convenience, clients MUST recompute the hash from the raw transaction if the preparing participant is not trusted.
+     * May be removed in future versions
+     *
+     * @generated from protobuf field: bytes prepared_transaction_hash = 2
+     */
+    preparedTransactionHash: Uint8Array;
+    /**
+     * The hashing scheme version used when building the hash
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.HashingSchemeVersion hashing_scheme_version = 3
+     */
+    hashingSchemeVersion: HashingSchemeVersion;
+    /**
+     * Optional additional details on how the transaction was encoded and hashed. Only set if verbose_hashing = true in the request
+     * Note that there are no guarantees on the stability of the format or content of this field.
+     * Its content should NOT be parsed and should only be used for troubleshooting purposes.
+     *
+     * @generated from protobuf field: optional string hashing_details = 4
+     */
+    hashingDetails?: string;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.Signature
+ */
+export interface Signature {
+    /**
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.SignatureFormat format = 1
+     */
+    format: SignatureFormat;
+    /**
+     * @generated from protobuf field: bytes signature = 2
+     */
+    signature: Uint8Array;
+    /**
+     * The fingerprint/id of the keypair used to create this signature and needed to verify.
+     *
+     * @generated from protobuf field: string signed_by = 3
+     */
+    signedBy: string;
+    /**
+     * The signing algorithm specification used to produce this signature
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.SigningAlgorithmSpec signing_algorithm_spec = 4
+     */
+    signingAlgorithmSpec: SigningAlgorithmSpec;
+}
+/**
+ * Signatures provided by a single party
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.SinglePartySignatures
+ */
+export interface SinglePartySignatures {
+    /**
+     * @generated from protobuf field: string party = 1
+     */
+    party: string;
+    /**
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.Signature signatures = 2
+     */
+    signatures: Signature[];
+}
+/**
+ * Additional signatures provided by the submitting parties
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.PartySignatures
+ */
+export interface PartySignatures {
+    /**
+     * Additional signatures provided by all individual parties
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.SinglePartySignatures signatures = 1
+     */
+    signatures: SinglePartySignatures[];
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.ExecuteSubmissionRequest
+ */
+export interface ExecuteSubmissionRequest {
+    /**
+     * the prepared transaction
+     * Typically this is the value of the `prepared_transaction` field in `PrepareSubmissionResponse`
+     * obtained from calling `prepareSubmission`.
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.PreparedTransaction prepared_transaction = 1
+     */
+    preparedTransaction?: PreparedTransaction;
+    /**
+     * The party(ies) signatures that authorize the prepared submission to be executed by this node.
+     * Each party can provide one or more signatures..
+     * and one or more parties can sign.
+     * Note that currently, only single party submissions are supported.
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.PartySignatures party_signatures = 2
+     */
+    partySignatures?: PartySignatures;
+    /**
+     * Specifies the deduplication period for the change ID (See PrepareSubmissionRequest).
+     * If omitted, the participant will assume the configured maximum deduplication time.
+     *
+     * @generated from protobuf oneof: deduplication_period
+     */
+    deduplicationPeriod: {
+        oneofKind: 'deduplicationDuration';
+        /**
+         * 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.
+         *
+         * @generated from protobuf field: google.protobuf.Duration deduplication_duration = 3
+         */
+        deduplicationDuration: Duration;
+    } | {
+        oneofKind: 'deduplicationOffset';
+        /**
+         * Specifies the start of the deduplication period by a completion stream offset (exclusive).
+         * Must be a valid absolute offset (positive integer).
+         *
+         * @generated from protobuf field: int64 deduplication_offset = 4
+         */
+        deduplicationOffset: bigint;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * 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``).
+     *
+     * Required
+     *
+     * @generated from protobuf field: string submission_id = 5
+     */
+    submissionId: string;
+    /**
+     * See [PrepareSubmissionRequest.user_id]
+     *
+     * @generated from protobuf field: string user_id = 6
+     */
+    userId: string;
+    /**
+     * The hashing scheme version used when building the hash
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.HashingSchemeVersion hashing_scheme_version = 7
+     */
+    hashingSchemeVersion: HashingSchemeVersion;
+    /**
+     * If set will influence the chosen ledger effective time but will not result in a submission delay so any override
+     * should be scheduled to executed within the window allowed by synchronizer.
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.MinLedgerTime min_ledger_time = 8
+     */
+    minLedgerTime?: MinLedgerTime;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.ExecuteSubmissionResponse
+ */
+export interface ExecuteSubmissionResponse {
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.MinLedgerTime
+ */
+export interface MinLedgerTime {
+    /**
+     * @generated from protobuf oneof: time
+     */
+    time: {
+        oneofKind: 'minLedgerTimeAbs';
+        /**
+         * Lower bound for the ledger time assigned to the resulting transaction.
+         * The ledger time of a transaction is assigned as part of command interpretation.
+         * Important note: for interactive submissions, if the transaction depends on time, it **must** be signed
+         * and submitted within a time window around the ledger time assigned to the transaction during the prepare method.
+         * The time delta around that ledger time is a configuration of the ledger, usually short, around 1 minute.
+         * If however the transaction does not depend on time, the available time window to sign and submit the transaction is bound
+         * by the preparation time, which is also assigned in the "prepare" step (this request),
+         * but can be configured with a much larger skew, allowing for more time to sign the request (in the order of hours).
+         * Must not be set at the same time as min_ledger_time_rel.
+         * Optional
+         *
+         * @generated from protobuf field: google.protobuf.Timestamp min_ledger_time_abs = 1
+         */
+        minLedgerTimeAbs: Timestamp;
+    } | {
+        oneofKind: 'minLedgerTimeRel';
+        /**
+         * Same as min_ledger_time_abs, but specified as a duration, starting from the time this request is received by the server.
+         * Must not be set at the same time as min_ledger_time_abs.
+         * Optional
+         *
+         * @generated from protobuf field: google.protobuf.Duration min_ledger_time_rel = 2
+         */
+        minLedgerTimeRel: Duration;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * *
+ * Prepared Transaction Message
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.PreparedTransaction
+ */
+export interface PreparedTransaction {
+    /**
+     * Daml Transaction representing the ledger effect if executed. See below
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.DamlTransaction transaction = 1
+     */
+    transaction?: DamlTransaction;
+    /**
+     * Metadata context necessary to execute the transaction
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.Metadata metadata = 2
+     */
+    metadata?: Metadata;
+}
+/**
+ * Transaction Metadata
+ * Refer to the hashing documentation for information on how it should be hashed.
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.Metadata
+ */
+export interface Metadata {
+    /**
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo submitter_info = 2
+     */
+    submitterInfo?: Metadata_SubmitterInfo;
+    /**
+     * @generated from protobuf field: string synchronizer_id = 3
+     */
+    synchronizerId: string;
+    /**
+     * @generated from protobuf field: uint32 mediator_group = 4
+     */
+    mediatorGroup: number;
+    /**
+     * @generated from protobuf field: string transaction_uuid = 5
+     */
+    transactionUuid: string;
+    /**
+     * @generated from protobuf field: uint64 preparation_time = 6
+     */
+    preparationTime: bigint;
+    /**
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.Metadata.InputContract input_contracts = 7
+     */
+    inputContracts: Metadata_InputContract[];
+    /**
+     *
+     * Where ledger time constraints are imposed during the execution of the contract they will be populated
+     * in the fields below. These are optional because if the transaction does NOT depend on time, these values
+     * do not need to be set.
+     * The final ledger effective time used will be chosen when the command is submitted through the [execute] RPC.
+     * If the ledger effective time is outside of any populated min/max bounds then a different transaction
+     * can result, that will cause a confirmation message rejection.
+     *
+     * @generated from protobuf field: optional uint64 min_ledger_effective_time = 9
+     */
+    minLedgerEffectiveTime?: bigint;
+    /**
+     * @generated from protobuf field: optional uint64 max_ledger_effective_time = 10
+     */
+    maxLedgerEffectiveTime?: bigint;
+    /**
+     * Contextual information needed to process the transaction but not signed, either because it's already indirectly
+     * signed by signing the transaction, or because it doesn't impact the ledger state
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry global_key_mapping = 8
+     */
+    globalKeyMapping: Metadata_GlobalKeyMappingEntry[];
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo
+ */
+export interface Metadata_SubmitterInfo {
+    /**
+     * @generated from protobuf field: repeated string act_as = 1
+     */
+    actAs: string[];
+    /**
+     * @generated from protobuf field: string command_id = 2
+     */
+    commandId: string;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry
+ */
+export interface Metadata_GlobalKeyMappingEntry {
+    /**
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.GlobalKey key = 1
+     */
+    key?: GlobalKey;
+    /**
+     * @generated from protobuf field: optional com.daml.ledger.api.v2.Value value = 2
+     */
+    value?: Value;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.Metadata.InputContract
+ */
+export interface Metadata_InputContract {
+    /**
+     * @generated from protobuf oneof: contract
+     */
+    contract: {
+        oneofKind: 'v1';
+        /**
+         * When new versions will be added, they will show here
+         *
+         * @generated from protobuf field: com.daml.ledger.api.v2.interactive.transaction.v1.Create v1 = 1
+         */
+        v1: Create;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * @generated from protobuf field: uint64 created_at = 1000
+     */
+    createdAt: bigint;
+    /**
+     * @generated from protobuf field: bytes event_blob = 1002
+     */
+    eventBlob: Uint8Array;
+}
+/**
+ *
+ * Daml Transaction.
+ * This represents the effect on the ledger if this transaction is successfully committed.
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction
+ */
+export interface DamlTransaction {
+    /**
+     * Transaction version, will be >= max(nodes version)
+     *
+     * @generated from protobuf field: string version = 1
+     */
+    version: string;
+    /**
+     * Root nodes of the transaction
+     *
+     * @generated from protobuf field: repeated string roots = 2
+     */
+    roots: string[];
+    /**
+     * List of nodes in the transaction
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.DamlTransaction.Node nodes = 3
+     */
+    nodes: DamlTransaction_Node[];
+    /**
+     * Node seeds are values associated with certain nodes used for generating cryptographic salts
+     *
+     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed node_seeds = 4
+     */
+    nodeSeeds: DamlTransaction_NodeSeed[];
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed
+ */
+export interface DamlTransaction_NodeSeed {
+    /**
+     * @generated from protobuf field: int32 node_id = 1
+     */
+    nodeId: number;
+    /**
+     * @generated from protobuf field: bytes seed = 2
+     */
+    seed: Uint8Array;
+}
+/**
+ * A transaction may contain nodes with different versions.
+ * Each node must be hashed using the hashing algorithm corresponding to its specific version.
+ * [docs-entry-start: DamlTransaction.Node]
+ *
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.Node
+ */
+export interface DamlTransaction_Node {
+    /**
+     * @generated from protobuf field: string node_id = 1
+     */
+    nodeId: string;
+    /**
+     * Versioned node
+     *
+     * @generated from protobuf oneof: versioned_node
+     */
+    versionedNode: {
+        oneofKind: 'v1';
+        /**
+         * Start at 1000 so we can add more fields before if necessary
+         * When new versions will be added, they will show here
+         *
+         * @generated from protobuf field: com.daml.ledger.api.v2.interactive.transaction.v1.Node v1 = 1000
+         */
+        v1: Node;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackageVersionRequest
+ */
+export interface GetPreferredPackageVersionRequest {
+    /**
+     * The parties whose participants' vetting state should be considered when resolving the preferred package.
+     * Required
+     *
+     * @generated from protobuf field: repeated string parties = 1
+     */
+    parties: string[];
+    /**
+     * The package-name for which the preferred package should be resolved.
+     * Required
+     *
+     * @generated from protobuf field: string package_name = 2
+     */
+    packageName: string;
+    /**
+     * The synchronizer whose vetting state to use for resolving this query.
+     * If not specified, the vetting state of all the synchronizers the participant is connected to will be used.
+     * Optional
+     *
+     * @generated from protobuf field: string synchronizer_id = 3
+     */
+    synchronizerId: string;
+    /**
+     * The timestamp at which the package vetting validity should be computed
+     * on the latest topology snapshot as seen by the participant.
+     * If not provided, the participant's current clock time is used.
+     * Optional
+     *
+     * @generated from protobuf field: google.protobuf.Timestamp vetting_valid_at = 4
+     */
+    vettingValidAt?: Timestamp;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackageVersionResponse
+ */
+export interface GetPreferredPackageVersionResponse {
+    /**
+     * Not populated when no preferred package is found
+     * Optional
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.interactive.PackagePreference package_preference = 1
+     */
+    packagePreference?: PackagePreference;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.interactive.PackagePreference
+ */
+export interface PackagePreference {
+    /**
+     * The package reference of the preferred package.
+     * Required
+     *
+     * @generated from protobuf field: com.daml.ledger.api.v2.PackageReference package_reference = 1
+     */
+    packageReference?: PackageReference;
+    /**
+     * The synchronizer for which the preferred package was computed.
+     * If the synchronizer_id was specified in the request, then it matches the request synchronizer_id.
+     * Required
+     *
+     * @generated from protobuf field: string synchronizer_id = 2
+     */
+    synchronizerId: string;
+}
+/**
+ * [docs-entry-start: HashingSchemeVersion]
+ * The hashing scheme version used when building the hash of the PreparedTransaction
+ *
+ * @generated from protobuf enum com.daml.ledger.api.v2.interactive.HashingSchemeVersion
+ */
+export declare enum HashingSchemeVersion {
+    /**
+     * @generated from protobuf enum value: HASHING_SCHEME_VERSION_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from protobuf enum value: HASHING_SCHEME_VERSION_V2 = 2;
+     */
+    V2 = 2
+}
+/**
+ * @generated from protobuf enum com.daml.ledger.api.v2.interactive.SigningAlgorithmSpec
+ */
+export declare enum SigningAlgorithmSpec {
+    /**
+     * @generated from protobuf enum value: SIGNING_ALGORITHM_SPEC_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * EdDSA Signature based on Curve25519 with SHA-512
+     * http://ed25519.cr.yp.to/
+     *
+     * @generated from protobuf enum value: SIGNING_ALGORITHM_SPEC_ED25519 = 1;
+     */
+    ED25519 = 1,
+    /**
+     * Elliptic Curve Digital Signature Algorithm with SHA256
+     *
+     * @generated from protobuf enum value: SIGNING_ALGORITHM_SPEC_EC_DSA_SHA_256 = 2;
+     */
+    EC_DSA_SHA_256 = 2,
+    /**
+     * Elliptic Curve Digital Signature Algorithm with SHA384
+     *
+     * @generated from protobuf enum value: SIGNING_ALGORITHM_SPEC_EC_DSA_SHA_384 = 3;
+     */
+    EC_DSA_SHA_384 = 3
+}
+/**
+ * @generated from protobuf enum com.daml.ledger.api.v2.interactive.SignatureFormat
+ */
+export declare enum SignatureFormat {
+    /**
+     * @generated from protobuf enum value: SIGNATURE_FORMAT_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Signature scheme specific signature format
+     * Legacy format no longer used, except for migrations
+     *
+     * @generated from protobuf enum value: SIGNATURE_FORMAT_RAW = 1;
+     */
+    RAW = 1,
+    /**
+     * ASN.1 + DER-encoding of the `r` and `s` integers, as defined in https://datatracker.ietf.org/doc/html/rfc3279#section-2.2.3
+     * Used for ECDSA signatures
+     *
+     * @generated from protobuf enum value: SIGNATURE_FORMAT_DER = 2;
+     */
+    DER = 2,
+    /**
+     * Concatenation of the integers `r || s` in little-endian form, as defined in https://datatracker.ietf.org/doc/html/rfc8032#section-3.3
+     * Note that this is different from the format defined in IEEE P1363, which uses concatenation in big-endian form.
+     * Used for EdDSA signatures
+     *
+     * @generated from protobuf enum value: SIGNATURE_FORMAT_CONCAT = 3;
+     */
+    CONCAT = 3,
+    /**
+     * Symbolic crypto, must only be used for testing
+     *
+     * @generated from protobuf enum value: SIGNATURE_FORMAT_SYMBOLIC = 10000;
+     */
+    SYMBOLIC = 10000
+}
+declare class PrepareSubmissionRequest$Type extends MessageType<PrepareSubmissionRequest> {
+    constructor();
+    create(value?: PartialMessage<PrepareSubmissionRequest>): PrepareSubmissionRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PrepareSubmissionRequest): PrepareSubmissionRequest;
+    internalBinaryWrite(message: PrepareSubmissionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.PrepareSubmissionRequest
+ */
+export declare const PrepareSubmissionRequest: PrepareSubmissionRequest$Type;
+declare class PrepareSubmissionResponse$Type extends MessageType<PrepareSubmissionResponse> {
+    constructor();
+    create(value?: PartialMessage<PrepareSubmissionResponse>): PrepareSubmissionResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PrepareSubmissionResponse): PrepareSubmissionResponse;
+    internalBinaryWrite(message: PrepareSubmissionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.PrepareSubmissionResponse
+ */
+export declare const PrepareSubmissionResponse: PrepareSubmissionResponse$Type;
+declare class Signature$Type extends MessageType<Signature> {
+    constructor();
+    create(value?: PartialMessage<Signature>): Signature;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Signature): Signature;
+    internalBinaryWrite(message: Signature, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Signature
+ */
+export declare const Signature: Signature$Type;
+declare class SinglePartySignatures$Type extends MessageType<SinglePartySignatures> {
+    constructor();
+    create(value?: PartialMessage<SinglePartySignatures>): SinglePartySignatures;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SinglePartySignatures): SinglePartySignatures;
+    internalBinaryWrite(message: SinglePartySignatures, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.SinglePartySignatures
+ */
+export declare const SinglePartySignatures: SinglePartySignatures$Type;
+declare class PartySignatures$Type extends MessageType<PartySignatures> {
+    constructor();
+    create(value?: PartialMessage<PartySignatures>): PartySignatures;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartySignatures): PartySignatures;
+    internalBinaryWrite(message: PartySignatures, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.PartySignatures
+ */
+export declare const PartySignatures: PartySignatures$Type;
+declare class ExecuteSubmissionRequest$Type extends MessageType<ExecuteSubmissionRequest> {
+    constructor();
+    create(value?: PartialMessage<ExecuteSubmissionRequest>): ExecuteSubmissionRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecuteSubmissionRequest): ExecuteSubmissionRequest;
+    internalBinaryWrite(message: ExecuteSubmissionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.ExecuteSubmissionRequest
+ */
+export declare const ExecuteSubmissionRequest: ExecuteSubmissionRequest$Type;
+declare class ExecuteSubmissionResponse$Type extends MessageType<ExecuteSubmissionResponse> {
+    constructor();
+    create(value?: PartialMessage<ExecuteSubmissionResponse>): ExecuteSubmissionResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecuteSubmissionResponse): ExecuteSubmissionResponse;
+    internalBinaryWrite(message: ExecuteSubmissionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.ExecuteSubmissionResponse
+ */
+export declare const ExecuteSubmissionResponse: ExecuteSubmissionResponse$Type;
+declare class MinLedgerTime$Type extends MessageType<MinLedgerTime> {
+    constructor();
+    create(value?: PartialMessage<MinLedgerTime>): MinLedgerTime;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MinLedgerTime): MinLedgerTime;
+    internalBinaryWrite(message: MinLedgerTime, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.MinLedgerTime
+ */
+export declare const MinLedgerTime: MinLedgerTime$Type;
+declare class PreparedTransaction$Type extends MessageType<PreparedTransaction> {
+    constructor();
+    create(value?: PartialMessage<PreparedTransaction>): PreparedTransaction;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PreparedTransaction): PreparedTransaction;
+    internalBinaryWrite(message: PreparedTransaction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.PreparedTransaction
+ */
+export declare const PreparedTransaction: PreparedTransaction$Type;
+declare class Metadata$Type extends MessageType<Metadata> {
+    constructor();
+    create(value?: PartialMessage<Metadata>): Metadata;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Metadata): Metadata;
+    internalBinaryWrite(message: Metadata, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata
+ */
+export declare const Metadata: Metadata$Type;
+declare class Metadata_SubmitterInfo$Type extends MessageType<Metadata_SubmitterInfo> {
+    constructor();
+    create(value?: PartialMessage<Metadata_SubmitterInfo>): Metadata_SubmitterInfo;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Metadata_SubmitterInfo): Metadata_SubmitterInfo;
+    internalBinaryWrite(message: Metadata_SubmitterInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo
+ */
+export declare const Metadata_SubmitterInfo: Metadata_SubmitterInfo$Type;
+declare class Metadata_GlobalKeyMappingEntry$Type extends MessageType<Metadata_GlobalKeyMappingEntry> {
+    constructor();
+    create(value?: PartialMessage<Metadata_GlobalKeyMappingEntry>): Metadata_GlobalKeyMappingEntry;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Metadata_GlobalKeyMappingEntry): Metadata_GlobalKeyMappingEntry;
+    internalBinaryWrite(message: Metadata_GlobalKeyMappingEntry, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry
+ */
+export declare const Metadata_GlobalKeyMappingEntry: Metadata_GlobalKeyMappingEntry$Type;
+declare class Metadata_InputContract$Type extends MessageType<Metadata_InputContract> {
+    constructor();
+    create(value?: PartialMessage<Metadata_InputContract>): Metadata_InputContract;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Metadata_InputContract): Metadata_InputContract;
+    internalBinaryWrite(message: Metadata_InputContract, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.InputContract
+ */
+export declare const Metadata_InputContract: Metadata_InputContract$Type;
+declare class DamlTransaction$Type extends MessageType<DamlTransaction> {
+    constructor();
+    create(value?: PartialMessage<DamlTransaction>): DamlTransaction;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DamlTransaction): DamlTransaction;
+    internalBinaryWrite(message: DamlTransaction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction
+ */
+export declare const DamlTransaction: DamlTransaction$Type;
+declare class DamlTransaction_NodeSeed$Type extends MessageType<DamlTransaction_NodeSeed> {
+    constructor();
+    create(value?: PartialMessage<DamlTransaction_NodeSeed>): DamlTransaction_NodeSeed;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DamlTransaction_NodeSeed): DamlTransaction_NodeSeed;
+    internalBinaryWrite(message: DamlTransaction_NodeSeed, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed
+ */
+export declare const DamlTransaction_NodeSeed: DamlTransaction_NodeSeed$Type;
+declare class DamlTransaction_Node$Type extends MessageType<DamlTransaction_Node> {
+    constructor();
+    create(value?: PartialMessage<DamlTransaction_Node>): DamlTransaction_Node;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DamlTransaction_Node): DamlTransaction_Node;
+    internalBinaryWrite(message: DamlTransaction_Node, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.Node
+ */
+export declare const DamlTransaction_Node: DamlTransaction_Node$Type;
+declare class GetPreferredPackageVersionRequest$Type extends MessageType<GetPreferredPackageVersionRequest> {
+    constructor();
+    create(value?: PartialMessage<GetPreferredPackageVersionRequest>): GetPreferredPackageVersionRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetPreferredPackageVersionRequest): GetPreferredPackageVersionRequest;
+    internalBinaryWrite(message: GetPreferredPackageVersionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackageVersionRequest
+ */
+export declare const GetPreferredPackageVersionRequest: GetPreferredPackageVersionRequest$Type;
+declare class GetPreferredPackageVersionResponse$Type extends MessageType<GetPreferredPackageVersionResponse> {
+    constructor();
+    create(value?: PartialMessage<GetPreferredPackageVersionResponse>): GetPreferredPackageVersionResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetPreferredPackageVersionResponse): GetPreferredPackageVersionResponse;
+    internalBinaryWrite(message: GetPreferredPackageVersionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackageVersionResponse
+ */
+export declare const GetPreferredPackageVersionResponse: GetPreferredPackageVersionResponse$Type;
+declare class PackagePreference$Type extends MessageType<PackagePreference> {
+    constructor();
+    create(value?: PartialMessage<PackagePreference>): PackagePreference;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PackagePreference): PackagePreference;
+    internalBinaryWrite(message: PackagePreference, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.PackagePreference
+ */
+export declare const PackagePreference: PackagePreference$Type;
+/**
+ * @generated ServiceType for protobuf service com.daml.ledger.api.v2.interactive.InteractiveSubmissionService
+ */
+export declare const InteractiveSubmissionService: ServiceType;
+export {};
+//# sourceMappingURL=interactive_submission_service.d.ts.map