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 { Duration } from '../../../../../../google/protobuf/duration.js';
import { PrefetchContractKey } from '../commands.js';
import { DisclosedContract } from '../commands.js';
import { Timestamp } from '../../../../../../google/protobuf/timestamp.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;
    /**
     * Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer specified in the `PrepareSubmissionResponse`.
     * If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again
     * with a new valid max_record_time.
     * Use this to limit the time-to-life of a prepared transaction,
     * which is useful to know when it can definitely not be accepted
     * anymore and resorting to preparing another transaction for the same
     * intent is safe again.
     * Optional
     *
     * @generated from protobuf field: optional google.protobuf.Timestamp max_record_time = 11
     */
    maxRecordTime?: Timestamp;
    /**
     * 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[];
    /**
     * Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer `synchronizer_id`.
     * If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again
     * with a new valid max_record_time.
     * Unsigned in 3.3 to avoid a breaking protocol change
     * Will be signed in 3.4+
     * Set max_record_time in the PreparedTransactionRequest to get this field set accordingly
     *
     * @generated from protobuf field: optional uint64 max_record_time = 11
     */
    maxRecordTime?: bigint;
}
/**
 * @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;
}
/**
 * Defines a package-name for which the commonly vetted package with the highest version must be found.
 *
 * @generated from protobuf message com.daml.ledger.api.v2.interactive.PackageVettingRequirement
 */
export interface PackageVettingRequirement {
    /**
     * 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;
}
/**
 * @generated from protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackagesRequest
 */
export interface GetPreferredPackagesRequest {
    /**
     * The package-name vetting requirements for which the preferred packages should be resolved.
     *
     * Generally it is enough to provide the requirements for the intended command's root package-names.
     * Additional package-name requirements can be provided when additional Daml transaction informees need to use
     * package dependencies of the command's root packages.
     *
     * Required
     *
     * @generated from protobuf field: repeated com.daml.ledger.api.v2.interactive.PackageVettingRequirement package_vetting_requirements = 1
     */
    packageVettingRequirements: PackageVettingRequirement[];
    /**
     * 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 = 2
     */
    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 = 3
     */
    vettingValidAt?: Timestamp;
}
/**
 * @generated from protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackagesResponse
 */
export interface GetPreferredPackagesResponse {
    /**
     * The package references of the preferred packages.
     * Must contain one package reference for each requested package-name.
     *
     * If you build command submissions whose content depends on the returned
     * preferred packages, then we recommend submitting the preferred package-ids
     * in the ``package_id_selection_preference`` of the command submission to
     * avoid race conditions with concurrent changes of the on-ledger package vetting state.
     *
     * Required
     *
     * @generated from protobuf field: repeated com.daml.ledger.api.v2.PackageReference package_references = 1
     */
    packageReferences: PackageReference[];
    /**
     * The synchronizer for which the package preferences are 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;
declare class PackageVettingRequirement$Type extends MessageType<PackageVettingRequirement> {
    constructor();
    create(value?: PartialMessage<PackageVettingRequirement>): PackageVettingRequirement;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PackageVettingRequirement): PackageVettingRequirement;
    internalBinaryWrite(message: PackageVettingRequirement, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.PackageVettingRequirement
 */
export declare const PackageVettingRequirement: PackageVettingRequirement$Type;
declare class GetPreferredPackagesRequest$Type extends MessageType<GetPreferredPackagesRequest> {
    constructor();
    create(value?: PartialMessage<GetPreferredPackagesRequest>): GetPreferredPackagesRequest;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetPreferredPackagesRequest): GetPreferredPackagesRequest;
    internalBinaryWrite(message: GetPreferredPackagesRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackagesRequest
 */
export declare const GetPreferredPackagesRequest: GetPreferredPackagesRequest$Type;
declare class GetPreferredPackagesResponse$Type extends MessageType<GetPreferredPackagesResponse> {
    constructor();
    create(value?: PartialMessage<GetPreferredPackagesResponse>): GetPreferredPackagesResponse;
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetPreferredPackagesResponse): GetPreferredPackagesResponse;
    internalBinaryWrite(message: GetPreferredPackagesResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
}
/**
 * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.GetPreferredPackagesResponse
 */
export declare const GetPreferredPackagesResponse: GetPreferredPackagesResponse$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