@distrohelena/canton-typescript-sdk 0.1.24 → 0.1.26

package/dist/daml-interface/runtime/daml-event-source-normalizer.d.ts

@@ -0,0 +1,52 @@
+import { GetContractResponse } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/contract_service.js";
+import { CreatedEvent, Event, ExercisedEvent } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/event.js";
+import { ActiveContract } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/state_service.js";
+import type { ContractResult, ExerciseResult } from "../../query/model-types.js";
+import type { DamlTypeIdentity, DamlValueSource } from "./daml-type-descriptor.js";
+export type DamlJsonEventRecord = Readonly<Record<string, unknown>>;
+export type DamlCreatedEventSource = CreatedEvent | GetContractResponse | ActiveContract | ContractResult | Event | DamlJsonEventRecord;
+export type DamlExercisedEventSource = ExercisedEvent | ExerciseResult | Event | DamlJsonEventRecord;
+export type DamlCreatedEventMetadata = {
+    readonly templateId: DamlTypeIdentity;
+    readonly offset?: string;
+    readonly nodeId?: number;
+    readonly witnessParties?: readonly string[];
+    readonly signatories?: readonly string[];
+    readonly observers?: readonly string[];
+    /** Canonical UTC ISO-8601 timestamp. */
+    readonly createdAt?: string;
+};
+export type DamlExercisedEventMetadata = {
+    readonly templateId: DamlTypeIdentity;
+    readonly offset?: string;
+    readonly nodeId?: number;
+    readonly actingParties?: readonly string[];
+    readonly witnessParties?: readonly string[];
+    readonly lastDescendantNodeId?: number;
+};
+export type DamlNormalizedCreatedEvent = {
+    readonly kind: "created";
+    readonly contractId: string;
+    readonly payload: DamlValueSource;
+    readonly metadata: DamlCreatedEventMetadata;
+};
+export type DamlNormalizedExercisedEvent = {
+    readonly kind: "exercised";
+    readonly contractId: string;
+    readonly choice: string;
+    readonly argument: DamlValueSource;
+    readonly result: DamlValueSource;
+    readonly consuming: boolean;
+    readonly metadata: DamlExercisedEventMetadata;
+};
+/**
+ * Recognizes a Ledger API create event, a contract response/wrapper, or a
+ * PQS/JSON contract record and produces one immutable runtime shape.
+ */
+export declare function normalizeDamlCreatedEventSource(source: DamlCreatedEventSource): DamlNormalizedCreatedEvent;
+/**
+ * Recognizes a Ledger API exercise event or a PQS/JSON exercise record and
+ * produces one immutable runtime shape. Choice information may be supplied by
+ * PQS's exercise-type relation and identity by its contract relation.
+ */
+export declare function normalizeDamlExercisedEventSource(source: DamlExercisedEventSource): DamlNormalizedExercisedEvent;

package/dist/daml-interface/runtime/daml-event-source-normalizer.js

@@ -0,0 +1,364 @@
+import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
+import { GetContractResponse } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/contract_service.js";
+import { CreatedEvent, ExercisedEvent } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/event.js";
+import { ActiveContract } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/state_service.js";
+import { DamlMaterializationError } from "./daml-materialization-error.js";
+const DAML_MIN_TIMESTAMP_SECONDS = -62135596800n;
+const DAML_MAX_TIMESTAMP_SECONDS = 253402300799n;
+/**
+ * Recognizes a Ledger API create event, a contract response/wrapper, or a
+ * PQS/JSON contract record and produces one immutable runtime shape.
+ */
+export function normalizeDamlCreatedEventSource(source) {
+    const recognized = findNestedEvent(source, "created");
+    const { event } = recognized;
+    const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "created event source");
+    const templateId = requiredIdentity(event, source, "created event source");
+    const payload = requiredProperty(event, ["createArguments", "create_arguments", "payload"], "created payload", "created event source");
+    const metadata = freezeCreatedMetadata(event, templateId);
+    return Object.freeze({
+        kind: "created",
+        contractId,
+        payload: freezeValueSource(payload, recognized.encoding === "protobuf" ? "protobuf-record" : "json"),
+        metadata,
+    });
+}
+/**
+ * Recognizes a Ledger API exercise event or a PQS/JSON exercise record and
+ * produces one immutable runtime shape. Choice information may be supplied by
+ * PQS's exercise-type relation and identity by its contract relation.
+ */
+export function normalizeDamlExercisedEventSource(source) {
+    const recognized = findNestedEvent(source, "exercised");
+    const { event } = recognized;
+    const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "exercised event source");
+    const templateId = requiredIdentity(event, source, "exercised event source");
+    const choice = requiredStringFrom(event, source, ["choice"], "choice", "exercised event source");
+    const consuming = requiredBooleanFrom(event, source, ["consuming"], "consuming", "exercised event source");
+    const argument = requiredProperty(event, ["choiceArgument", "choice_argument", "argument"], "exercise argument", "exercised event source");
+    const result = requiredProperty(event, ["exerciseResult", "exercise_result", "result"], "exercise result", "exercised event source");
+    const metadata = freezeExercisedMetadata(event, source, templateId);
+    return Object.freeze({
+        kind: "exercised",
+        contractId,
+        choice,
+        argument: freezeValueSource(argument, recognized.encoding),
+        result: freezeValueSource(result, recognized.encoding),
+        consuming,
+        metadata,
+    });
+}
+function findNestedEvent(source, kind) {
+    const root = objectOrThrow(source, `${kind} event source`, "source must be an object");
+    const candidates = [];
+    const aliases = kind === "created" ? ["createdEvent", "created_event"] : ["exercisedEvent", "exercised_event"];
+    if (looksLikeEvent(root, kind)) {
+        candidates.push({ event: root, encoding: protobufEncoding(root, kind) });
+    }
+    for (const alias of aliases) {
+        if (hasValue(root, alias)) {
+            candidates.push({ event: objectOrThrow(root[alias], `${kind} event source`, "event must be an object"), encoding: protobufEncoding(root, kind) });
+        }
+    }
+    const nested = asObject(root.event);
+    if (nested !== undefined) {
+        const nestedAliases = kind === "created" ? ["created", "createdEvent", "created_event"] : ["exercised", "exercisedEvent", "exercised_event"];
+        for (const alias of nestedAliases) {
+            if (hasValue(nested, alias)) {
+                candidates.push({ event: objectOrThrow(nested[alias], `${kind} event source`, "event must be an object"), encoding: protobufEncoding(nested[alias], kind) });
+            }
+        }
+    }
+    if (candidates.length === 0) {
+        throw sourceError(`${kind} event source`, "no event or payload was found");
+    }
+    else if (candidates.length !== 1) {
+        throw sourceError(`${kind} event source`, "ambiguous nested event");
+    }
+    return candidates[0];
+}
+function protobufEncoding(value, kind) {
+    if (isGeneratedMessage(value, kind === "created" ? CreatedEvent : ExercisedEvent)) {
+        return "protobuf";
+    }
+    else if (kind === "created" && (isGeneratedMessage(value, GetContractResponse) || isGeneratedMessage(value, ActiveContract))) {
+        return "protobuf";
+    }
+    return "json";
+}
+function isGeneratedMessage(value, type) {
+    return value !== null
+        && typeof value === "object"
+        && value[MESSAGE_TYPE] === type;
+}
+function looksLikeEvent(value, kind) {
+    const fields = kind === "created"
+        ? ["contractId", "contract_id", "templateId", "template_id", "createArguments", "create_arguments", "payload"]
+        : ["contractId", "contract_id", "templateId", "template_id", "choiceArgument", "choice_argument", "argument", "exerciseResult", "exercise_result", "result"];
+    return fields.some((field) => Object.prototype.hasOwnProperty.call(value, field));
+}
+function requiredIdentity(event, source, path) {
+    const direct = readProperty(event, ["templateId", "template_id"]);
+    if (direct.found) {
+        return identityFrom(direct.value, path);
+    }
+    const root = asObject(source);
+    const contract = asObject(readProperty(event, ["contract"]).value) ?? asObject(root?.contract);
+    const contractIdentity = contract === undefined ? { found: false } : readProperty(contract, ["templateId", "template_id"]);
+    if (contractIdentity.found) {
+        return identityFrom(contractIdentity.value, path);
+    }
+    const type = asObject(readProperty(event, ["exerciseType", "exercise_type", "contractType", "contract_type"]).value)
+        ?? asObject(root?.exerciseType)
+        ?? asObject(root?.exercise_type)
+        ?? asObject(root?.contractType)
+        ?? asObject(root?.contract_type);
+    const packageRecord = asObject(readProperty(event, ["package"]).value) ?? asObject(root?.package);
+    if (type !== undefined) {
+        return identityFrom({
+            packageId: readProperty(type, ["packageId", "package_id"]).value ?? readProperty(packageRecord ?? {}, ["id", "packageId", "package_id"]).value,
+            moduleName: readProperty(type, ["moduleName", "module_name"]).value,
+            entityName: readProperty(type, ["entityName", "entity_name"]).value,
+        }, path);
+    }
+    throw sourceError(path, "template identity is absent");
+}
+function identityFrom(value, path) {
+    const identifier = asObject(value);
+    if (identifier === undefined) {
+        throw sourceError(path, "template identity is absent");
+    }
+    const packageId = stringValue(readProperty(identifier, ["packageId", "package_id"]).value);
+    const moduleName = stringValue(readProperty(identifier, ["moduleName", "module_name"]).value);
+    const entityName = stringValue(readProperty(identifier, ["entityName", "entity_name"]).value);
+    if (packageId === undefined || moduleName === undefined || entityName === undefined) {
+        throw sourceError(path, "template identity is incomplete");
+    }
+    return Object.freeze({ packageId, moduleName, entityName });
+}
+function freezeCreatedMetadata(event, templateId) {
+    return Object.freeze(removeUndefined({
+        templateId,
+        offset: optionalString(event, ["offset", "createdEventOffset", "created_event_offset"], "offset", "created event source"),
+        nodeId: optionalNodeId(event, ["nodeId", "node_id"], "node ID", "created event source"),
+        witnessParties: optionalStringArray(event, ["witnessParties", "witness_parties", "witnesses"], "witness parties", "created event source"),
+        signatories: optionalStringArray(event, ["signatories"], "signatories", "created event source"),
+        observers: optionalStringArray(event, ["observers"], "observers", "created event source"),
+        createdAt: optionalCreatedAt(event, ["createdAt", "created_at"], "created event source"),
+    }));
+}
+function freezeExercisedMetadata(event, source, templateId) {
+    const root = asObject(source);
+    const transaction = asObject(readProperty(event, ["transaction"]).value) ?? asObject(root?.transaction);
+    return Object.freeze(removeUndefined({
+        templateId,
+        offset: optionalString(event, ["offset"], "offset", "exercised event source")
+            ?? optionalString(transaction ?? {}, ["offset"], "offset", "exercised event source"),
+        nodeId: optionalNodeId(event, ["nodeId", "node_id"], "node ID", "exercised event source"),
+        actingParties: optionalStringArray(event, ["actingParties", "acting_parties", "controllers"], "acting parties", "exercised event source"),
+        witnessParties: optionalStringArray(event, ["witnessParties", "witness_parties", "witnesses"], "witness parties", "exercised event source"),
+        lastDescendantNodeId: optionalNodeId(event, ["lastDescendantNodeId", "last_descendant_node_id"], "last descendant node ID", "exercised event source"),
+    }));
+}
+function requiredStringFrom(event, source, names, label, path) {
+    const direct = readProperty(event, names);
+    if (direct.found) {
+        return requiredStringValue(direct.value, label, path);
+    }
+    const root = asObject(source);
+    const type = asObject(readProperty(event, ["exerciseType", "exercise_type"]).value)
+        ?? asObject(root?.exerciseType)
+        ?? asObject(root?.exercise_type);
+    const nested = type === undefined ? { found: false } : readProperty(type, names);
+    return requiredStringValue(nested.value, label, path);
+}
+function requiredBooleanFrom(event, source, names, label, path) {
+    const direct = readProperty(event, names);
+    if (direct.found) {
+        return requiredBooleanValue(direct.value, label, path);
+    }
+    const root = asObject(source);
+    const type = asObject(readProperty(event, ["exerciseType", "exercise_type"]).value)
+        ?? asObject(root?.exerciseType)
+        ?? asObject(root?.exercise_type);
+    const nested = type === undefined ? { found: false } : readProperty(type, names);
+    return requiredBooleanValue(nested.value, label, path);
+}
+function requiredString(event, names, label, path) {
+    return requiredStringValue(readProperty(event, names).value, label, path);
+}
+function requiredStringValue(value, label, path) {
+    const string = stringValue(value);
+    if (string === undefined) {
+        throw sourceError(path, `${label} is absent`);
+    }
+    return string;
+}
+function requiredBooleanValue(value, label, path) {
+    if (typeof value !== "boolean") {
+        throw sourceError(path, `${label} is absent`);
+    }
+    return value;
+}
+function requiredProperty(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        throw sourceError(path, `${label} is absent`);
+    }
+    return property.value;
+}
+function freezeValueSource(value, encoding) {
+    if (encoding === "protobuf") {
+        return Object.freeze({ kind: "protobuf", value: cloneAndFreeze(value) });
+    }
+    else if (encoding === "protobuf-record") {
+        return Object.freeze({
+            kind: "protobuf",
+            value: cloneAndFreeze({ sum: { oneofKind: "record", record: value } }),
+        });
+    }
+    return Object.freeze({ kind: "json", value: cloneAndFreeze(value) });
+}
+function optionalString(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        return undefined;
+    }
+    const value = stringValue(property.value);
+    if (value === undefined) {
+        throw sourceError(path, `${label} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalNodeId(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        return undefined;
+    }
+    const value = property.value;
+    const number = typeof value === "number" ? value : typeof value === "string" && /^\d+$/.test(value) ? Number(value) : undefined;
+    if (number === undefined || !Number.isSafeInteger(number) || number < 0) {
+        throw sourceError(path, `${label} must be a non-negative safe integer`);
+    }
+    return number;
+}
+function optionalStringArray(event, names, label, path) {
+    const property = readProperty(event, names);
+    if (!property.found) {
+        return undefined;
+    }
+    else if (!Array.isArray(property.value) || !property.value.every((item) => typeof item === "string")) {
+        throw sourceError(path, `${label} must be an array of strings`);
+    }
+    return cloneAndFreeze(property.value);
+}
+function optionalCreatedAt(event, names, path) {
+    const property = readProperty(event, names);
+    if (!property.found || property.value === null) {
+        return undefined;
+    }
+    else if (property.value instanceof Date) {
+        return canonicalDateTimestamp(property.value, path);
+    }
+    else if (typeof property.value === "string") {
+        return canonicalIsoTimestamp(property.value, path);
+    }
+    return canonicalProtobufTimestamp(property.value, path);
+}
+function canonicalIsoTimestamp(value, path) {
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z$/.exec(value);
+    if (match === null) {
+        throw sourceError(path, "created at must be a UTC ISO-8601 timestamp");
+    }
+    const milliseconds = (match[2] ?? "").padEnd(3, "0").slice(0, 3);
+    const date = new Date(`${match[1]}.${milliseconds}Z`);
+    if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 19) !== match[1]) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    requireLedgerTimestampSeconds(BigInt(Math.floor(date.getTime() / 1000)), path);
+    return `${match[1]}.${(match[2] ?? "").padEnd(9, "0")}Z`;
+}
+function canonicalProtobufTimestamp(value, path) {
+    const timestamp = asObject(value);
+    const seconds = timestamp === undefined ? undefined : readProperty(timestamp, ["seconds"]).value;
+    const nanos = timestamp === undefined ? undefined : readProperty(timestamp, ["nanos"]).value;
+    if (typeof seconds !== "string" || !/^-?\d+$/.test(seconds) || typeof nanos !== "number" || !Number.isSafeInteger(nanos) || nanos < 0 || nanos > 999999999) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    const secondsValue = BigInt(seconds);
+    requireLedgerTimestampSeconds(secondsValue, path);
+    const date = new Date(Number(secondsValue * 1000n));
+    if (Number.isNaN(date.getTime())) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    const base = date.toISOString().replace(".000Z", "");
+    return `${base}.${nanos.toString().padStart(9, "0")}Z`;
+}
+function canonicalDateTimestamp(value, path) {
+    const milliseconds = value.getTime();
+    if (Number.isNaN(milliseconds)) {
+        throw sourceError(path, "created at must be a valid timestamp");
+    }
+    requireLedgerTimestampSeconds(BigInt(Math.floor(milliseconds / 1000)), path);
+    return value.toISOString().replace(/\.(\d{3})Z$/, (_match, milliseconds) => `.${milliseconds}000000Z`);
+}
+function requireLedgerTimestampSeconds(seconds, path) {
+    if (seconds < DAML_MIN_TIMESTAMP_SECONDS || seconds > DAML_MAX_TIMESTAMP_SECONDS) {
+        throw sourceError(path, "created at must be within DAML timestamp bounds");
+    }
+}
+function readProperty(object, names) {
+    for (const name of names) {
+        if (Object.prototype.hasOwnProperty.call(object, name) && object[name] !== undefined) {
+            return { found: true, value: object[name] };
+        }
+    }
+    return { found: false };
+}
+function hasValue(object, name) {
+    return Object.prototype.hasOwnProperty.call(object, name) && object[name] !== undefined;
+}
+function objectOrThrow(value, path, detail) {
+    const object = asObject(value);
+    if (object === undefined) {
+        throw sourceError(path, detail);
+    }
+    return object;
+}
+function asObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function cloneAndFreeze(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    else if (value instanceof Date) {
+        return Object.freeze(new Date(value.getTime()));
+    }
+    const existing = seen.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const output = Array.isArray(value)
+        ? []
+        : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, output);
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor !== undefined && "value" in descriptor) {
+            Object.defineProperty(output, key, { ...descriptor, value: cloneAndFreeze(descriptor.value, seen) });
+        }
+    }
+    return Object.freeze(output);
+}
+function removeUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined));
+}
+function sourceError(path, detail) {
+    return new DamlMaterializationError(path, detail);
+}

package/dist/daml-interface/runtime/daml-materialization-error.d.ts

@@ -0,0 +1,5 @@
+/** Raised when a transport value cannot be materialized as its DAML descriptor. */
+export declare class DamlMaterializationError extends Error {
+    readonly path: string;
+    constructor(path: string, detail: string);
+}

package/dist/daml-interface/runtime/daml-materialization-error.js

@@ -0,0 +1,9 @@
+/** Raised when a transport value cannot be materialized as its DAML descriptor. */
+export class DamlMaterializationError extends Error {
+    path;
+    constructor(path, detail) {
+        super(`${path}: ${detail}`);
+        this.name = "DamlMaterializationError";
+        this.path = path;
+    }
+}

package/dist/daml-interface/runtime/daml-template.d.ts

@@ -0,0 +1,6 @@
+/** Base class for generated DAML template bindings. */
+export declare class DamlTemplate {
+    #private;
+    constructor(contractId: string);
+    get contractId(): string;
+}

package/dist/daml-interface/runtime/daml-template.js

@@ -0,0 +1,10 @@
+/** Base class for generated DAML template bindings. */
+export class DamlTemplate {
+    #contractId;
+    constructor(contractId) {
+        this.#contractId = contractId;
+    }
+    get contractId() {
+        return this.#contractId;
+    }
+}

package/dist/daml-interface/runtime/daml-type-descriptor.d.ts

@@ -0,0 +1,71 @@
+import { Value } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/value.js";
+export type DamlTypeIdentity = {
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly entityName: string;
+};
+export type DamlPrimitiveType = "unit" | "bool" | "int64" | "date" | "timestamp" | "numeric" | "party" | "text";
+export type DamlPrimitiveDescriptor = {
+    readonly kind: "primitive";
+    readonly primitive: DamlPrimitiveType;
+    readonly numericScale?: number;
+};
+export type DamlContractIdDescriptor = {
+    readonly kind: "contractId";
+    readonly contract?: DamlTypeDescriptor;
+};
+export type DamlOptionalDescriptor = {
+    readonly kind: "optional";
+    readonly element: DamlTypeDescriptor;
+};
+export type DamlListDescriptor = {
+    readonly kind: "list";
+    readonly element: DamlTypeDescriptor;
+};
+export type DamlTextMapDescriptor = {
+    readonly kind: "textMap";
+    readonly value: DamlTypeDescriptor;
+};
+export type DamlGenMapDescriptor = {
+    readonly kind: "genMap";
+    readonly key: DamlTypeDescriptor;
+    readonly value: DamlTypeDescriptor;
+};
+export type DamlRecordFieldDescriptor = {
+    readonly damlLabel: string;
+    readonly propertyName: string;
+    readonly type: DamlTypeDescriptor;
+};
+export type DamlRecordDescriptor = {
+    readonly kind: "record";
+    readonly fields: readonly DamlRecordFieldDescriptor[];
+};
+export type DamlVariantConstructorDescriptor = {
+    readonly constructor: string;
+    readonly payload: DamlTypeDescriptor;
+};
+export type DamlVariantDescriptor = {
+    readonly kind: "variant";
+    readonly constructors: readonly DamlVariantConstructorDescriptor[];
+};
+export type DamlEnumDescriptor = {
+    readonly kind: "enum";
+    readonly constructors: readonly string[];
+};
+export type DamlNamedReferenceDescriptor = {
+    readonly kind: "namedReference";
+    readonly identity: DamlTypeIdentity;
+};
+/** A closed description of a serializable DAML value. */
+export type DamlTypeDescriptor = DamlPrimitiveDescriptor | DamlContractIdDescriptor | DamlOptionalDescriptor | DamlListDescriptor | DamlTextMapDescriptor | DamlGenMapDescriptor | DamlRecordDescriptor | DamlVariantDescriptor | DamlEnumDescriptor | DamlNamedReferenceDescriptor;
+/** Resolves named descriptors lazily so recursive data types remain finite. */
+export type DamlTypeDescriptorRegistry = {
+    readonly resolve: (identity: DamlTypeIdentity) => (() => DamlTypeDescriptor) | undefined;
+};
+export type DamlValueSource = {
+    readonly kind: "protobuf";
+    readonly value: Value;
+} | {
+    readonly kind: "json";
+    readonly value: unknown;
+};

package/dist/daml-interface/runtime/daml-type-descriptor.js

@@ -0,0 +1 @@
+export {};

package/dist/daml-interface/runtime/daml-value-converter.d.ts

@@ -0,0 +1,7 @@
+import { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant } from "../../core/types/daml-values.js";
+import { DamlNumeric } from "../../core/types/daml-numeric.js";
+import { DamlParty } from "../../core/types/daml-party.js";
+import { DamlTypeDescriptor, DamlTypeDescriptorRegistry, DamlValueSource } from "./daml-type-descriptor.js";
+export type DamlDecodedValue = DamlUnit | boolean | bigint | DamlDate | DamlTimestamp | DamlNumeric | DamlParty | string | undefined | readonly DamlDecodedValue[] | DamlTextMap | DamlGenMap | DamlRecord | DamlVariant | DamlEnum;
+/** Decodes a protobuf or JSON/PQS DAML value according to its generated descriptor. */
+export declare function decodeDamlValue(source: DamlValueSource, descriptor: DamlTypeDescriptor, registry: DamlTypeDescriptorRegistry, path: string): DamlDecodedValue;