@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/com/daml/ledger/api/v2/command_completion_service.client.d.ts

@@ -0,0 +1,66 @@
+import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
+import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
+import type { CompletionStreamResponse } from './command_completion_service.js';
+import type { CompletionStreamRequest } from './command_completion_service.js';
+import type { ServerStreamingCall } from '@protobuf-ts/runtime-rpc';
+import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
+/**
+ * Allows clients to observe the status of their submissions.
+ * Commands may be submitted via the Command Submission Service.
+ * The on-ledger effects of their submissions are disclosed by the Update Service.
+ *
+ * Commands may fail in 2 distinct manners:
+ *
+ * 1. Failure communicated synchronously in the gRPC error of the submission.
+ * 2. Failure communicated asynchronously in a Completion, see ``completion.proto``.
+ *
+ * Note that not only successfully submitted commands MAY produce a completion event. For example, the participant MAY
+ * choose to produce a completion event for a rejection of a duplicate command.
+ *
+ * Clients that do not receive a successful completion about their submission MUST NOT assume that it was successful.
+ * Clients SHOULD subscribe to the CompletionStream before starting to submit commands to prevent race conditions.
+ *
+ * @generated from protobuf service com.daml.ledger.api.v2.CommandCompletionService
+ */
+export interface ICommandCompletionServiceClient {
+    /**
+     * Subscribe to command completion events.
+     *
+     * @generated from protobuf rpc: CompletionStream
+     */
+    completionStream(input: CompletionStreamRequest, options?: RpcOptions): ServerStreamingCall<CompletionStreamRequest, CompletionStreamResponse>;
+}
+/**
+ * Allows clients to observe the status of their submissions.
+ * Commands may be submitted via the Command Submission Service.
+ * The on-ledger effects of their submissions are disclosed by the Update Service.
+ *
+ * Commands may fail in 2 distinct manners:
+ *
+ * 1. Failure communicated synchronously in the gRPC error of the submission.
+ * 2. Failure communicated asynchronously in a Completion, see ``completion.proto``.
+ *
+ * Note that not only successfully submitted commands MAY produce a completion event. For example, the participant MAY
+ * choose to produce a completion event for a rejection of a duplicate command.
+ *
+ * Clients that do not receive a successful completion about their submission MUST NOT assume that it was successful.
+ * Clients SHOULD subscribe to the CompletionStream before starting to submit commands to prevent race conditions.
+ *
+ * @generated from protobuf service com.daml.ledger.api.v2.CommandCompletionService
+ */
+export declare class CommandCompletionServiceClient implements ICommandCompletionServiceClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * Subscribe to command completion events.
+     *
+     * @generated from protobuf rpc: CompletionStream
+     */
+    completionStream(input: CompletionStreamRequest, options?: RpcOptions): ServerStreamingCall<CompletionStreamRequest, CompletionStreamResponse>;
+}
+//# sourceMappingURL=command_completion_service.client.d.ts.map

package/dist/_proto/com/daml/ledger/api/v2/command_completion_service.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_completion_service.client.d.ts","sourceRoot":"","sources":["../../../../../../../src/_proto/com/daml/ledger/api/v2/command_completion_service.client.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAG3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAA;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AAC9E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,+BAA+B;IAC5C;;;;OAIG;IACH,gBAAgB,CACZ,KAAK,EAAE,uBAAuB,EAC9B,OAAO,CAAC,EAAE,UAAU,GACrB,mBAAmB,CAAC,uBAAuB,EAAE,wBAAwB,CAAC,CAAA;CAC5E;AACD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,8BACT,YAAW,+BAA+B,EAAE,WAAW;IAK3C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAHvC,QAAQ,SAAoC;IAC5C,OAAO,4DAAmC;IAC1C,OAAO;;MAAmC;gBACb,UAAU,EAAE,YAAY;IACrD;;;;OAIG;IACH,gBAAgB,CACZ,KAAK,EAAE,uBAAuB,EAC9B,OAAO,CAAC,EAAE,UAAU,GACrB,mBAAmB,CAAC,uBAAuB,EAAE,wBAAwB,CAAC;CAQ5E"}

package/dist/_proto/com/daml/ledger/api/v2/command_completion_service.client.js

@@ -0,0 +1,38 @@
+import { CommandCompletionService } from './command_completion_service.js';
+import { stackIntercept } from '@protobuf-ts/runtime-rpc';
+/**
+ * Allows clients to observe the status of their submissions.
+ * Commands may be submitted via the Command Submission Service.
+ * The on-ledger effects of their submissions are disclosed by the Update Service.
+ *
+ * Commands may fail in 2 distinct manners:
+ *
+ * 1. Failure communicated synchronously in the gRPC error of the submission.
+ * 2. Failure communicated asynchronously in a Completion, see ``completion.proto``.
+ *
+ * Note that not only successfully submitted commands MAY produce a completion event. For example, the participant MAY
+ * choose to produce a completion event for a rejection of a duplicate command.
+ *
+ * Clients that do not receive a successful completion about their submission MUST NOT assume that it was successful.
+ * Clients SHOULD subscribe to the CompletionStream before starting to submit commands to prevent race conditions.
+ *
+ * @generated from protobuf service com.daml.ledger.api.v2.CommandCompletionService
+ */
+export class CommandCompletionServiceClient {
+    _transport;
+    typeName = CommandCompletionService.typeName;
+    methods = CommandCompletionService.methods;
+    options = CommandCompletionService.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * Subscribe to command completion events.
+     *
+     * @generated from protobuf rpc: CompletionStream
+     */
+    completionStream(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept('serverStreaming', this._transport, method, opt, input);
+    }
+}

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

@@ -0,0 +1,90 @@
+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 { OffsetCheckpoint } from './offset_checkpoint.js';
+import { Completion } from './completion.js';
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.CompletionStreamRequest
+ */
+export interface CompletionStreamRequest {
+    /**
+     * Only completions of commands submitted with the same user_id will be visible in the stream.
+     * Must be a valid UserIdString (as described in ``value.proto``).
+     * Required unless authentication is used with a user token.
+     * In that case, the token's user-id will be used for the request's user_id.
+     *
+     * @generated from protobuf field: string user_id = 1
+     */
+    userId: string;
+    /**
+     * Non-empty list of parties whose data should be included.
+     * The stream shows only completions of commands for which at least one of the ``act_as`` parties is in the given set of parties.
+     * Must be a valid PartyIdString (as described in ``value.proto``).
+     * Required
+     *
+     * @generated from protobuf field: repeated string parties = 2
+     */
+    parties: string[];
+    /**
+     * This optional field indicates the minimum offset for completions. This can be used to resume an earlier completion stream.
+     * If not set the ledger uses the ledger begin offset instead.
+     * If specified, it must be a valid absolute offset (positive integer) or zero (ledger begin offset).
+     * If the ledger has been pruned, this parameter must be specified and greater than the pruning offset.
+     *
+     * @generated from protobuf field: int64 begin_exclusive = 3
+     */
+    beginExclusive: bigint;
+}
+/**
+ * @generated from protobuf message com.daml.ledger.api.v2.CompletionStreamResponse
+ */
+export interface CompletionStreamResponse {
+    /**
+     * @generated from protobuf oneof: completion_response
+     */
+    completionResponse: {
+        oneofKind: 'completion';
+        /**
+         * @generated from protobuf field: com.daml.ledger.api.v2.Completion completion = 1
+         */
+        completion: Completion;
+    } | {
+        oneofKind: 'offsetCheckpoint';
+        /**
+         * @generated from protobuf field: com.daml.ledger.api.v2.OffsetCheckpoint offset_checkpoint = 2
+         */
+        offsetCheckpoint: OffsetCheckpoint;
+    } | {
+        oneofKind: undefined;
+    };
+}
+declare class CompletionStreamRequest$Type extends MessageType<CompletionStreamRequest> {
+    constructor();
+    create(value?: PartialMessage<CompletionStreamRequest>): CompletionStreamRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CompletionStreamRequest): CompletionStreamRequest;
+    internalBinaryWrite(message: CompletionStreamRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.CompletionStreamRequest
+ */
+export declare const CompletionStreamRequest: CompletionStreamRequest$Type;
+declare class CompletionStreamResponse$Type extends MessageType<CompletionStreamResponse> {
+    constructor();
+    create(value?: PartialMessage<CompletionStreamResponse>): CompletionStreamResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CompletionStreamResponse): CompletionStreamResponse;
+    internalBinaryWrite(message: CompletionStreamResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.CompletionStreamResponse
+ */
+export declare const CompletionStreamResponse: CompletionStreamResponse$Type;
+/**
+ * @generated ServiceType for protobuf service com.daml.ledger.api.v2.CommandCompletionService
+ */
+export declare const CommandCompletionService: ServiceType;
+export {};
+//# sourceMappingURL=command_completion_service.d.ts.map

package/dist/_proto/com/daml/ledger/api/v2/command_completion_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_completion_service.d.ts","sourceRoot":"","sources":["../../../../../../../src/_proto/com/daml/ledger/api/v2/command_completion_service.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,CAAA;CACzB;AACD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACrC;;OAEG;IACH,kBAAkB,EACZ;QACI,SAAS,EAAE,YAAY,CAAA;QACvB;;WAEG;QACH,UAAU,EAAE,UAAU,CAAA;KACzB,GACD;QACI,SAAS,EAAE,kBAAkB,CAAA;QAC7B;;WAEG;QACH,gBAAgB,EAAE,gBAAgB,CAAA;KACrC,GACD;QACI,SAAS,EAAE,SAAS,CAAA;KACvB,CAAA;CACV;AAED,cAAM,4BAA6B,SAAQ,WAAW,CAAC,uBAAuB,CAAC;;IAyB3E,MAAM,CACF,KAAK,CAAC,EAAE,cAAc,CAAC,uBAAuB,CAAC,GAChD,uBAAuB;IAa1B,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,uBAAuB,GACjC,uBAAuB;IAkC1B,mBAAmB,CACf,OAAO,EAAE,uBAAuB,EAChC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAmBnB;AACD;;GAEG;AACH,eAAO,MAAM,uBAAuB,8BAAqC,CAAA;AAEzE,cAAM,6BAA8B,SAAQ,WAAW,CAAC,wBAAwB,CAAC;;IAmB7E,MAAM,CACF,KAAK,CAAC,EAAE,cAAc,CAAC,wBAAwB,CAAC,GACjD,wBAAwB;IAW3B,kBAAkB,CACd,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,EAC1B,MAAM,CAAC,EAAE,wBAAwB,GAClC,wBAAwB;IA+C3B,mBAAmB,CACf,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,GAC5B,aAAa;CAwBnB;AACD;;GAEG;AACH,eAAO,MAAM,wBAAwB,+BAAsC,CAAA;AAC3E;;GAEG;AACH,eAAO,MAAM,wBAAwB,aAWpC,CAAA"}

package/dist/_proto/com/daml/ledger/api/v2/command_completion_service.js

@@ -0,0 +1,178 @@
+// @generated by protobuf-ts 2.11.1 with parameter generate_dependencies
+// @generated from protobuf file "com/daml/ledger/api/v2/command_completion_service.proto" (package "com.daml.ledger.api.v2", syntax proto3)
+// tslint:disable
+//
+// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+import { ServiceType } from '@protobuf-ts/runtime-rpc';
+import { WireType } from '@protobuf-ts/runtime';
+import { UnknownFieldHandler } from '@protobuf-ts/runtime';
+import { reflectionMergePartial } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+import { OffsetCheckpoint } from './offset_checkpoint.js';
+import { Completion } from './completion.js';
+// @generated message type with reflection information, may provide speed optimized methods
+class CompletionStreamRequest$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.CompletionStreamRequest', [
+            {
+                no: 1,
+                name: 'user_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'parties',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'begin_exclusive',
+                kind: 'scalar',
+                T: 3 /*ScalarType.INT64*/,
+                L: 0 /*LongType.BIGINT*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.userId = '';
+        message.parties = [];
+        message.beginExclusive = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string user_id */ 1:
+                    message.userId = reader.string();
+                    break;
+                case /* repeated string parties */ 2:
+                    message.parties.push(reader.string());
+                    break;
+                case /* int64 begin_exclusive */ 3:
+                    message.beginExclusive = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string user_id = 1; */
+        if (message.userId !== '')
+            writer.tag(1, WireType.LengthDelimited).string(message.userId);
+        /* repeated string parties = 2; */
+        for (let i = 0; i < message.parties.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.parties[i]);
+        /* int64 begin_exclusive = 3; */
+        if (message.beginExclusive !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.beginExclusive);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.CompletionStreamRequest
+ */
+export const CompletionStreamRequest = new CompletionStreamRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CompletionStreamResponse$Type extends MessageType {
+    constructor() {
+        super('com.daml.ledger.api.v2.CompletionStreamResponse', [
+            {
+                no: 1,
+                name: 'completion',
+                kind: 'message',
+                oneof: 'completionResponse',
+                T: () => Completion,
+            },
+            {
+                no: 2,
+                name: 'offset_checkpoint',
+                kind: 'message',
+                oneof: 'completionResponse',
+                T: () => OffsetCheckpoint,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.completionResponse = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* com.daml.ledger.api.v2.Completion completion */ 1:
+                    message.completionResponse = {
+                        oneofKind: 'completion',
+                        completion: Completion.internalBinaryRead(reader, reader.uint32(), options, message.completionResponse.completion),
+                    };
+                    break;
+                case /* com.daml.ledger.api.v2.OffsetCheckpoint offset_checkpoint */ 2:
+                    message.completionResponse = {
+                        oneofKind: 'offsetCheckpoint',
+                        offsetCheckpoint: OffsetCheckpoint.internalBinaryRead(reader, reader.uint32(), options, message.completionResponse.offsetCheckpoint),
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === 'throw')
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* com.daml.ledger.api.v2.Completion completion = 1; */
+        if (message.completionResponse.oneofKind === 'completion')
+            Completion.internalBinaryWrite(message.completionResponse.completion, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* com.daml.ledger.api.v2.OffsetCheckpoint offset_checkpoint = 2; */
+        if (message.completionResponse.oneofKind === 'offsetCheckpoint')
+            OffsetCheckpoint.internalBinaryWrite(message.completionResponse.offsetCheckpoint, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.CompletionStreamResponse
+ */
+export const CompletionStreamResponse = new CompletionStreamResponse$Type();
+/**
+ * @generated ServiceType for protobuf service com.daml.ledger.api.v2.CommandCompletionService
+ */
+export const CommandCompletionService = new ServiceType('com.daml.ledger.api.v2.CommandCompletionService', [
+    {
+        name: 'CompletionStream',
+        serverStreaming: true,
+        options: {},
+        I: CompletionStreamRequest,
+        O: CompletionStreamResponse,
+    },
+]);

package/dist/_proto/com/daml/ledger/api/v2/command_service.client.d.ts

@@ -0,0 +1,99 @@
+import type { RpcTransport } from '@protobuf-ts/runtime-rpc';
+import type { ServiceInfo } from '@protobuf-ts/runtime-rpc';
+import type { SubmitAndWaitForReassignmentResponse } from './command_service.js';
+import type { SubmitAndWaitForReassignmentRequest } from './command_service.js';
+import type { SubmitAndWaitForTransactionTreeResponse } from './command_service.js';
+import type { SubmitAndWaitForTransactionResponse } from './command_service.js';
+import type { SubmitAndWaitForTransactionRequest } from './command_service.js';
+import type { SubmitAndWaitResponse } from './command_service.js';
+import type { SubmitAndWaitRequest } from './command_service.js';
+import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
+/**
+ * Command Service is able to correlate submitted commands with completion data, identify timeouts, and return contextual
+ * information with each tracking result. This supports the implementation of stateless clients.
+ *
+ * Note that submitted commands generally produce completion events as well, even in case a command gets rejected.
+ * For example, the participant SHOULD produce a completion event for a rejection of a duplicate command.
+ *
+ * @generated from protobuf service com.daml.ledger.api.v2.CommandService
+ */
+export interface ICommandServiceClient {
+    /**
+     * Submits a single composite command and waits for its result.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWait
+     */
+    submitAndWait(input: SubmitAndWaitRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitRequest, SubmitAndWaitResponse>;
+    /**
+     * Submits a single composite command, waits for its result, and returns the transaction.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForTransaction
+     */
+    submitAndWaitForTransaction(input: SubmitAndWaitForTransactionRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitForTransactionRequest, SubmitAndWaitForTransactionResponse>;
+    /**
+     * Provided for backwards compatibility, it will be removed in the Canton version 3.4.0.
+     * Submits a single composite command, waits for its result, and returns the transaction tree.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForTransactionTree
+     */
+    submitAndWaitForTransactionTree(input: SubmitAndWaitRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitRequest, SubmitAndWaitForTransactionTreeResponse>;
+    /**
+     * Submits a single composite reassignment command, waits for its result, and returns the reassignment.
+     * Propagates the gRPC error of failed submission.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForReassignment
+     */
+    submitAndWaitForReassignment(input: SubmitAndWaitForReassignmentRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitForReassignmentRequest, SubmitAndWaitForReassignmentResponse>;
+}
+/**
+ * Command Service is able to correlate submitted commands with completion data, identify timeouts, and return contextual
+ * information with each tracking result. This supports the implementation of stateless clients.
+ *
+ * Note that submitted commands generally produce completion events as well, even in case a command gets rejected.
+ * For example, the participant SHOULD produce a completion event for a rejection of a duplicate command.
+ *
+ * @generated from protobuf service com.daml.ledger.api.v2.CommandService
+ */
+export declare class CommandServiceClient implements ICommandServiceClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: import("@protobuf-ts/runtime-rpc").MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: import("@protobuf-ts/runtime").JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * Submits a single composite command and waits for its result.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWait
+     */
+    submitAndWait(input: SubmitAndWaitRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitRequest, SubmitAndWaitResponse>;
+    /**
+     * Submits a single composite command, waits for its result, and returns the transaction.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForTransaction
+     */
+    submitAndWaitForTransaction(input: SubmitAndWaitForTransactionRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitForTransactionRequest, SubmitAndWaitForTransactionResponse>;
+    /**
+     * Provided for backwards compatibility, it will be removed in the Canton version 3.4.0.
+     * Submits a single composite command, waits for its result, and returns the transaction tree.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForTransactionTree
+     */
+    submitAndWaitForTransactionTree(input: SubmitAndWaitRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitRequest, SubmitAndWaitForTransactionTreeResponse>;
+    /**
+     * Submits a single composite reassignment command, waits for its result, and returns the reassignment.
+     * Propagates the gRPC error of failed submission.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForReassignment
+     */
+    submitAndWaitForReassignment(input: SubmitAndWaitForReassignmentRequest, options?: RpcOptions): UnaryCall<SubmitAndWaitForReassignmentRequest, SubmitAndWaitForReassignmentResponse>;
+}
+//# sourceMappingURL=command_service.client.d.ts.map

package/dist/_proto/com/daml/ledger/api/v2/command_service.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_service.client.d.ts","sourceRoot":"","sources":["../../../../../../../src/_proto/com/daml/ledger/api/v2/command_service.client.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAE3D,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,sBAAsB,CAAA;AAChF,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,sBAAsB,CAAA;AAC/E,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,sBAAsB,CAAA;AAC/E,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,sBAAsB,CAAA;AAE9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;;;OAKG;IACH,aAAa,CACT,KAAK,EAAE,oBAAoB,EAC3B,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CAAC,oBAAoB,EAAE,qBAAqB,CAAC,CAAA;IACzD;;;;;OAKG;IACH,2BAA2B,CACvB,KAAK,EAAE,kCAAkC,EACzC,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CACR,kCAAkC,EAClC,mCAAmC,CACtC,CAAA;IACD;;;;;;OAMG;IACH,+BAA+B,CAC3B,KAAK,EAAE,oBAAoB,EAC3B,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CAAC,oBAAoB,EAAE,uCAAuC,CAAC,CAAA;IAC3E;;;;;OAKG;IACH,4BAA4B,CACxB,KAAK,EAAE,mCAAmC,EAC1C,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CACR,mCAAmC,EACnC,oCAAoC,CACvC,CAAA;CACJ;AACD;;;;;;;;GAQG;AACH,qBAAa,oBACT,YAAW,qBAAqB,EAAE,WAAW;IAKjC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAHvC,QAAQ,SAA0B;IAClC,OAAO,4DAAyB;IAChC,OAAO;;MAAyB;gBACH,UAAU,EAAE,YAAY;IACrD;;;;;OAKG;IACH,aAAa,CACT,KAAK,EAAE,oBAAoB,EAC3B,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CAAC,oBAAoB,EAAE,qBAAqB,CAAC;IAWzD;;;;;OAKG;IACH,2BAA2B,CACvB,KAAK,EAAE,kCAAkC,EACzC,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CACR,kCAAkC,EAClC,mCAAmC,CACtC;IAQD;;;;;;OAMG;IACH,+BAA+B,CAC3B,KAAK,EAAE,oBAAoB,EAC3B,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CACR,oBAAoB,EACpB,uCAAuC,CAC1C;IAQD;;;;;OAKG;IACH,4BAA4B,CACxB,KAAK,EAAE,mCAAmC,EAC1C,OAAO,CAAC,EAAE,UAAU,GACrB,SAAS,CACR,mCAAmC,EACnC,oCAAoC,CACvC;CAQJ"}

package/dist/_proto/com/daml/ledger/api/v2/command_service.client.js

@@ -0,0 +1,61 @@
+import { CommandService } from './command_service.js';
+import { stackIntercept } from '@protobuf-ts/runtime-rpc';
+/**
+ * Command Service is able to correlate submitted commands with completion data, identify timeouts, and return contextual
+ * information with each tracking result. This supports the implementation of stateless clients.
+ *
+ * Note that submitted commands generally produce completion events as well, even in case a command gets rejected.
+ * For example, the participant SHOULD produce a completion event for a rejection of a duplicate command.
+ *
+ * @generated from protobuf service com.daml.ledger.api.v2.CommandService
+ */
+export class CommandServiceClient {
+    _transport;
+    typeName = CommandService.typeName;
+    methods = CommandService.methods;
+    options = CommandService.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * Submits a single composite command and waits for its result.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWait
+     */
+    submitAndWait(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept('unary', this._transport, method, opt, input);
+    }
+    /**
+     * Submits a single composite command, waits for its result, and returns the transaction.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForTransaction
+     */
+    submitAndWaitForTransaction(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept('unary', this._transport, method, opt, input);
+    }
+    /**
+     * Provided for backwards compatibility, it will be removed in the Canton version 3.4.0.
+     * Submits a single composite command, waits for its result, and returns the transaction tree.
+     * Propagates the gRPC error of failed submissions including Daml interpretation errors.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForTransactionTree
+     */
+    submitAndWaitForTransactionTree(input, options) {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept('unary', this._transport, method, opt, input);
+    }
+    /**
+     * Submits a single composite reassignment command, waits for its result, and returns the reassignment.
+     * Propagates the gRPC error of failed submission.
+     *
+     * @generated from protobuf rpc: SubmitAndWaitForReassignment
+     */
+    submitAndWaitForReassignment(input, options) {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept('unary', this._transport, method, opt, input);
+    }
+}