@distrohelena/canton-typescript-sdk 0.1.0

package/dist/transports/grpc/generated/canton/google/protobuf/timestamp.d.ts

@@ -0,0 +1,148 @@
+import type { JsonValue } from "@protobuf-ts/runtime";
+import type { JsonReadOptions } from "@protobuf-ts/runtime";
+import type { JsonWriteOptions } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A ProtoJSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a ProtoJSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ *
+ *
+ * @generated from protobuf message google.protobuf.Timestamp
+ */
+export interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
+     * be between -62135596800 and 253402300799 inclusive (which corresponds to
+     * 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
+     *
+     * @generated from protobuf field: int64 seconds = 1
+     */
+    seconds: string;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. This field is
+     * the nanosecond portion of the duration, not an alternative to seconds.
+     * Negative second values with fractions must still have non-negative nanos
+     * values that count forward in time. Must be between 0 and 999,999,999
+     * inclusive.
+     *
+     * @generated from protobuf field: int32 nanos = 2
+     */
+    nanos: number;
+}
+declare class Timestamp$Type extends MessageType<Timestamp> {
+    constructor();
+    /**
+     * Creates a new `Timestamp` for the current time.
+     */
+    now(): Timestamp;
+    /**
+     * Converts a `Timestamp` to a JavaScript Date.
+     */
+    toDate(message: Timestamp): Date;
+    /**
+     * Converts a JavaScript Date to a `Timestamp`.
+     */
+    fromDate(date: Date): Timestamp;
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue;
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Timestamp
+ */
+export declare const Timestamp: Timestamp$Type;
+export {};

package/dist/transports/grpc/generated/canton/google/protobuf/timestamp.js

@@ -0,0 +1,121 @@
+// @generated by protobuf-ts 2.11.1 with parameter force_server_none,force_optimize_code_size,long_type_string
+// @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
+// tslint:disable
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+import { typeofJsonValue } from "@protobuf-ts/runtime";
+import { PbLong } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+// @generated message type with reflection information, may provide speed optimized methods
+class Timestamp$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Timestamp", [
+            { no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/ },
+            { no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    /**
+     * Creates a new `Timestamp` for the current time.
+     */
+    now() {
+        const msg = this.create();
+        const ms = Date.now();
+        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toString();
+        msg.nanos = (ms % 1000) * 1000000;
+        return msg;
+    }
+    /**
+     * Converts a `Timestamp` to a JavaScript Date.
+     */
+    toDate(message) {
+        return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000));
+    }
+    /**
+     * Converts a JavaScript Date to a `Timestamp`.
+     */
+    fromDate(date) {
+        const msg = this.create();
+        const ms = date.getTime();
+        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toString();
+        msg.nanos = ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000;
+        return msg;
+    }
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonWrite(message, options) {
+        let ms = PbLong.from(message.seconds).toNumber() * 1000;
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+            throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+        if (message.nanos < 0)
+            throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
+        let z = "Z";
+        if (message.nanos > 0) {
+            let nanosStr = (message.nanos + 1000000000).toString().substring(1);
+            if (nanosStr.substring(3) === "000000")
+                z = "." + nanosStr.substring(0, 3) + "Z";
+            else if (nanosStr.substring(6) === "000")
+                z = "." + nanosStr.substring(0, 6) + "Z";
+            else
+                z = "." + nanosStr + "Z";
+        }
+        return new Date(ms).toISOString().replace(".000Z", z);
+    }
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonRead(json, options, target) {
+        if (typeof json !== "string")
+            throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
+        let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+        if (!matches)
+            throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
+        let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+        if (Number.isNaN(ms))
+            throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+            throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+        if (!target)
+            target = this.create();
+        target.seconds = PbLong.from(ms / 1000).toString();
+        target.nanos = 0;
+        if (matches[7])
+            target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000);
+        return target;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Timestamp
+ */
+export const Timestamp = new Timestamp$Type();

package/dist/transports/grpc/generated/canton/google/rpc/status.d.ts

@@ -0,0 +1,46 @@
+import { MessageType } from "@protobuf-ts/runtime";
+import { Any } from "../protobuf/any.js";
+/**
+ * The `Status` type defines a logical error model that is suitable for
+ * different programming environments, including REST APIs and RPC APIs. It is
+ * used by [gRPC](https://github.com/grpc). Each `Status` message contains
+ * three pieces of data: error code, error message, and error details.
+ *
+ * You can find out more about this error model and how to work with it in the
+ * [API Design Guide](https://cloud.google.com/apis/design/errors).
+ *
+ * @generated from protobuf message google.rpc.Status
+ */
+export interface Status {
+    /**
+     * The status code, which should be an enum value of
+     * [google.rpc.Code][google.rpc.Code].
+     *
+     * @generated from protobuf field: int32 code = 1
+     */
+    code: number;
+    /**
+     * A developer-facing error message, which should be in English. Any
+     * user-facing error message should be localized and sent in the
+     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized
+     * by the client.
+     *
+     * @generated from protobuf field: string message = 2
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.  There is a common set of
+     * message types for APIs to use.
+     *
+     * @generated from protobuf field: repeated google.protobuf.Any details = 3
+     */
+    details: Any[];
+}
+declare class Status$Type extends MessageType<Status> {
+    constructor();
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.Status
+ */
+export declare const Status: Status$Type;
+export {};

package/dist/transports/grpc/generated/canton/google/rpc/status.js

@@ -0,0 +1,34 @@
+// @generated by protobuf-ts 2.11.1 with parameter force_server_none,force_optimize_code_size,long_type_string
+// @generated from protobuf file "google/rpc/status.proto" (package "google.rpc", syntax proto3)
+// tslint:disable
+//
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+import { MessageType } from "@protobuf-ts/runtime";
+import { Any } from "../protobuf/any.js";
+// @generated message type with reflection information, may provide speed optimized methods
+class Status$Type extends MessageType {
+    constructor() {
+        super("google.rpc.Status", [
+            { no: 1, name: "code", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "details", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Any }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.Status
+ */
+export const Status = new Status$Type();

package/dist/transports/grpc/grpc-call-options-factory.d.ts

@@ -0,0 +1,8 @@
+import { IAuthProvider } from "../../core/auth/auth-provider.interface.js";
+import { RequestOptions } from "../../core/types/request-options.js";
+import { GrpcChannelSecurity } from "../../core/types/grpc-channel-security.js";
+export declare function createGrpcChannelCredentials(security: GrpcChannelSecurity): import("@grpc/grpc-js").ChannelCredentials;
+export declare function buildGrpcCallOptionsAsync(authProvider?: IAuthProvider, defaultTimeoutMs?: number, options?: RequestOptions): Promise<{
+    meta: Record<string, string>;
+    timeout?: number;
+}>;

package/dist/transports/grpc/grpc-call-options-factory.js

@@ -0,0 +1,19 @@
+import { credentials } from "@grpc/grpc-js";
+import { resolveRequestTimeoutMs } from "../../core/types/request-timeout.js";
+import { GrpcChannelSecurity } from "../../core/types/grpc-channel-security.js";
+export function createGrpcChannelCredentials(security) {
+    return security === GrpcChannelSecurity.insecure
+        ? credentials.createInsecure()
+        : credentials.createSsl();
+}
+export async function buildGrpcCallOptionsAsync(authProvider, defaultTimeoutMs, options) {
+    const timeout = resolveRequestTimeoutMs(defaultTimeoutMs, options);
+    return timeout === undefined
+        ? {
+            meta: authProvider ? await authProvider.getHeadersAsync() : {},
+        }
+        : {
+            meta: authProvider ? await authProvider.getHeadersAsync() : {},
+            timeout,
+        };
+}

package/dist/transports/grpc/grpc-channel-factory.d.ts

@@ -0,0 +1,141 @@
+import { CantonClientOptions } from "../../client/canton-client-options.js";
+import { IPackageServiceClient as IParticipantPackageServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/package_service.client.js";
+import { IPartyManagementServiceClient as IParticipantPartyManagementServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/party_management_service.client.js";
+import { IParticipantInspectionServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_inspection_service.client.js";
+import { IParticipantRepairServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_repair_service.client.js";
+import { IPruningServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/pruning_service.client.js";
+import { IResourceManagementServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/resource_management_service.client.js";
+import { IParticipantStatusServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/participant_status_service.client.js";
+import { ISynchronizerConnectivityServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/synchronizer_connectivity_service.client.js";
+import { ITrafficControlServiceClient } from "./generated/canton/com/digitalasset/canton/admin/participant/v30/traffic_control_service.client.js";
+import { IIdentityInitializationServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/initialization_service.client.js";
+import { ITopologyAggregationServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_aggregation_service.client.js";
+import { ITopologyManagerReadServiceClient } from "./generated/canton/com/digitalasset/canton/topology/admin/v30/topology_manager_read_service.client.js";
+import { ICommandInspectionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/command_inspection_service.client.js";
+import { IIdentityProviderConfigServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/identity_provider_config_service.client.js";
+import { IPackageManagementServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/package_management_service.client.js";
+import { IPackageServiceClient as ILedgerPackageServiceClient } from "./generated/canton/com/daml/ledger/api/v2/package_service.client.js";
+import { IPartyManagementServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/party_management_service.client.js";
+import { IUserManagementServiceClient } from "./generated/canton/com/daml/ledger/api/v2/admin/user_management_service.client.js";
+import { IVersionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/version_service.client.js";
+import { ICommandServiceClient } from "./generated/canton/com/daml/ledger/api/v2/command_service.client.js";
+import { ICommandCompletionServiceClient } from "./generated/canton/com/daml/ledger/api/v2/command_completion_service.client.js";
+import { IContractServiceClient } from "./generated/canton/com/daml/ledger/api/v2/contract_service.client.js";
+import { IEventQueryServiceClient } from "./generated/canton/com/daml/ledger/api/v2/event_query_service.client.js";
+import { IStateServiceClient } from "./generated/canton/com/daml/ledger/api/v2/state_service.client.js";
+import { IUpdateServiceClient } from "./generated/canton/com/daml/ledger/api/v2/update_service.client.js";
+import { IHealthClient } from "./generated/canton/google/grpc/health/v1/health.client.js";
+import { RequestOptions } from "../../core/types/request-options.js";
+import { GrpcChannelSecurity } from "../../core/types/grpc-channel-security.js";
+export interface GrpcOperations {
+    disposeAsync?(): Promise<void>;
+    checkHealthAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getHealthAsync(options?: RequestOptions): Promise<unknown>;
+    createPartyAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listPartiesAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getPartiesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    grantUserRightsAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getCommandStatusAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getUserAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listUsersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listUserRightsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    uploadPackageAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listKnownPackagesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getIdentityProviderConfigAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listIdentityProviderConfigsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listPackagesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getPackageAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getPackageStatusAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listVettedPackagesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listParticipantPackagesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantPackageContentsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantPackageReferencesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantDarAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listParticipantDarsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantDarContentsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantStatusAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    lookupOffsetByTimeAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    openCommitmentAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    inspectCommitmentContractsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    countInFlightAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getConfigForSlowCounterParticipantsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getIntervalsBehindForCounterParticipantsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    lookupSentAcsCommitmentsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    lookupReceivedAcsCommitmentsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getHighestOffsetByTimestampAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getSafePruningOffsetAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getPruningScheduleAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getParticipantPruningScheduleAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getNoWaitCommitmentsFromAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    trafficControlStateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listConnectedSynchronizersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getSynchronizerIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listRegisteredSynchronizersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listPendingOperationsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getResourceLimitsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    currentTimeAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listNamespaceDelegationAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listDecentralizedNamespaceDefinitionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listOwnerToKeyMappingAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listPartyToKeyMappingAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listSynchronizerTrustCertificateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listParticipantSynchronizerPermissionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listPartyHostingLimitsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    topologyListVettedPackagesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listPartyToParticipantAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listSynchronizerParametersStateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listSequencingParametersStateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listMediatorSynchronizerStateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listSequencerSynchronizerStateAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listLsuAnnouncementAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listLsuSequencerConnectionSuccessorAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listAvailableStoresAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listAllAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listAllV2Async?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    topologyListPartiesAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    listKeyOwnersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getContractAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getEventsByContractIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    queryContractsAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getConnectedSynchronizersAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getLedgerEndAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getLatestPrunedOffsetsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    streamTransactionsAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getUpdateByOffsetAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getUpdateByIdAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getUpdateByHashAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getUpdatesPageAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    getCompletionsAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
+    submitCommandAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+}
+export interface GrpcOperationDependencies {
+    versionServiceClient?: Pick<IVersionServiceClient, "getLedgerApiVersion">;
+    healthClient?: Pick<IHealthClient, "check">;
+    partyManagementServiceClient?: Pick<IPartyManagementServiceClient, "allocateParty" | "listKnownParties" | "getParticipantId" | "getParties">;
+    userManagementServiceClient?: Pick<IUserManagementServiceClient, "grantUserRights" | "getUser" | "listUsers" | "listUserRights">;
+    commandInspectionServiceClient?: Pick<ICommandInspectionServiceClient, "getCommandStatus">;
+    identityProviderConfigServiceClient?: Pick<IIdentityProviderConfigServiceClient, "getIdentityProviderConfig" | "listIdentityProviderConfigs">;
+    packageManagementServiceClient?: Pick<IPackageManagementServiceClient, "uploadDarFile" | "listKnownPackages">;
+    ledgerPackageServiceClient?: Pick<ILedgerPackageServiceClient, "listPackages" | "getPackage" | "getPackageStatus" | "listVettedPackages">;
+    participantPackageServiceClient?: Pick<IParticipantPackageServiceClient, "listPackages" | "getPackageContents" | "getPackageReferences" | "getDar" | "listDars" | "getDarContents">;
+    participantInspectionServiceClient?: Pick<IParticipantInspectionServiceClient, "lookupOffsetByTime" | "openCommitment" | "inspectCommitmentContracts" | "countInFlight" | "getConfigForSlowCounterParticipants" | "getIntervalsBehindForCounterParticipants" | "lookupSentAcsCommitments" | "lookupReceivedAcsCommitments">;
+    participantPartyManagementServiceClient?: Pick<IParticipantPartyManagementServiceClient, "getHighestOffsetByTimestamp">;
+    participantRepairServiceClient?: Pick<IParticipantRepairServiceClient, "listPendingOperations">;
+    pruningServiceClient?: Pick<IPruningServiceClient, "getSafePruningOffset" | "getSchedule" | "getParticipantSchedule" | "getNoWaitCommitmentsFrom">;
+    participantStatusServiceClient?: Pick<IParticipantStatusServiceClient, "participantStatus">;
+    synchronizerConnectivityServiceClient?: Pick<ISynchronizerConnectivityServiceClient, "listConnectedSynchronizers" | "getSynchronizerId" | "listRegisteredSynchronizers">;
+    trafficControlServiceClient?: Pick<ITrafficControlServiceClient, "trafficControlState">;
+    resourceManagementServiceClient?: Pick<IResourceManagementServiceClient, "getResourceLimits">;
+    identityInitializationServiceClient?: Pick<IIdentityInitializationServiceClient, "getId" | "currentTime">;
+    topologyManagerReadServiceClient?: Pick<ITopologyManagerReadServiceClient, "listNamespaceDelegation" | "listDecentralizedNamespaceDefinition" | "listOwnerToKeyMapping" | "listPartyToKeyMapping" | "listSynchronizerTrustCertificate" | "listParticipantSynchronizerPermission" | "listPartyHostingLimits" | "listVettedPackages" | "listPartyToParticipant" | "listSynchronizerParametersState" | "listSequencingParametersState" | "listMediatorSynchronizerState" | "listSequencerSynchronizerState" | "listLsuAnnouncement" | "listLsuSequencerConnectionSuccessor" | "listAvailableStores" | "listAll" | "listAllV2">;
+    topologyAggregationServiceClient?: Pick<ITopologyAggregationServiceClient, "listParties" | "listKeyOwners">;
+    contractServiceClient?: Pick<IContractServiceClient, "getContract">;
+    eventQueryServiceClient?: Pick<IEventQueryServiceClient, "getEventsByContractId">;
+    stateServiceClient?: Pick<IStateServiceClient, "getActiveContractsPage" | "getConnectedSynchronizers" | "getLedgerEnd" | "getLatestPrunedOffsets">;
+    updateServiceClient?: Pick<IUpdateServiceClient, "getUpdates" | "getUpdateByOffset" | "getUpdateById" | "getUpdateByHash" | "getUpdatesPage">;
+    commandCompletionServiceClient?: Pick<ICommandCompletionServiceClient, "getCompletions">;
+    commandServiceClient?: Pick<ICommandServiceClient, "submitAndWait">;
+}
+export declare function createGrpcOperations(options: CantonClientOptions, endpoint: string, grpcChannelSecurity: GrpcChannelSecurity, dependencies?: GrpcOperationDependencies): GrpcOperations;