@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

package/dist/core/types/commands/exercise-command.js

@@ -8,10 +8,10 @@ export class ExerciseCommand {
         if (!init.templateId) {
             throw new ValidationError("exercise commands require a templateId");
         }
-        if (!init.contractId) {
+        else if (!init.contractId) {
             throw new ValidationError("exercise commands require a contractId");
         }
-        if (!init.choice) {
+        else if (!init.choice) {
             throw new ValidationError("exercise commands require a choice");
         }
         this.templateId = init.templateId;

package/dist/core/types/daml-numeric.d.ts

@@ -0,0 +1,6 @@
+/** Exact decimal DAML Numeric value, encoded without floating-point rounding. */
+export declare class DamlNumeric {
+    readonly value: string;
+    constructor(value: string);
+    toJSON(): string;
+}

package/dist/core/types/daml-numeric.js

@@ -0,0 +1,14 @@
+import { ValidationError } from "../errors/validation-error.js";
+/** Exact decimal DAML Numeric value, encoded without floating-point rounding. */
+export class DamlNumeric {
+    value;
+    constructor(value) {
+        if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
+            throw new ValidationError("DAML numeric values must be exact decimal strings");
+        }
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/core/types/daml-party.d.ts

@@ -0,0 +1,6 @@
+/** Explicit DAML Party value for commands whose field type is Party, not Text. */
+export declare class DamlParty {
+    readonly value: string;
+    constructor(value: string);
+    toJSON(): string;
+}

package/dist/core/types/daml-party.js

@@ -0,0 +1,14 @@
+import { ValidationError } from "../errors/validation-error.js";
+/** Explicit DAML Party value for commands whose field type is Party, not Text. */
+export class DamlParty {
+    value;
+    constructor(value) {
+        if (value.length === 0) {
+            throw new ValidationError("DAML party values must not be empty");
+        }
+        this.value = value;
+    }
+    toJSON() {
+        return this.value;
+    }
+}

package/dist/core/types/requests/create-decentralized-party-request.d.ts

@@ -0,0 +1,41 @@
+import { ExternalPartySigningPublicKey } from "../external-party/external-party-signing-public-key.js";
+import { ExternalPartySigningRequest, ExternalPartySigningResult } from "./create-external-party-request.js";
+export interface DecentralizedPartyKey {
+    readonly publicKey: ExternalPartySigningPublicKey;
+    readonly sign?: DecentralizedPartySigner;
+}
+export interface DecentralizedPartySigningRequest extends ExternalPartySigningRequest {
+    readonly role: "owner" | "partySigningKey";
+    readonly transactionHash: Uint8Array;
+}
+export type DecentralizedPartySigner = (request: DecentralizedPartySigningRequest) => Promise<ExternalPartySigningResult>;
+export declare class CreateDecentralizedPartyRequest {
+    readonly synchronizer: string;
+    readonly partyHint: string;
+    readonly owners: readonly DecentralizedPartyKey[];
+    readonly ownerThreshold: number;
+    readonly partySigningKeys: readonly DecentralizedPartyKey[];
+    readonly partySigningThreshold: number;
+    readonly localParticipantObservationOnly: boolean;
+    readonly otherConfirmingParticipantUids: readonly string[];
+    readonly confirmationThreshold: number;
+    readonly observingParticipantUids: readonly string[];
+    readonly identityProviderId?: string;
+    readonly waitForAllocation?: boolean;
+    readonly userId?: string;
+    constructor(init: {
+        synchronizer?: string;
+        partyHint?: string;
+        owners?: readonly DecentralizedPartyKey[];
+        ownerThreshold?: number;
+        partySigningKeys?: readonly DecentralizedPartyKey[];
+        partySigningThreshold?: number;
+        localParticipantObservationOnly?: boolean;
+        otherConfirmingParticipantUids?: readonly string[];
+        confirmationThreshold?: number;
+        observingParticipantUids?: readonly string[];
+        identityProviderId?: string;
+        waitForAllocation?: boolean;
+        userId?: string;
+    });
+}

package/dist/core/types/requests/create-decentralized-party-request.js

@@ -0,0 +1,82 @@
+import { ValidationError } from "../../errors/validation-error.js";
+import { computeCantonPublicKeyFingerprint } from "../../hashing/canton-hash.js";
+import { ExternalPartySigningPublicKey } from "../external-party/external-party-signing-public-key.js";
+export class CreateDecentralizedPartyRequest {
+    synchronizer;
+    partyHint;
+    owners;
+    ownerThreshold;
+    partySigningKeys;
+    partySigningThreshold;
+    localParticipantObservationOnly;
+    otherConfirmingParticipantUids;
+    confirmationThreshold;
+    observingParticipantUids;
+    identityProviderId;
+    waitForAllocation;
+    userId;
+    constructor(init) {
+        const owners = [...(init.owners ?? [])];
+        const partySigningKeys = [...(init.partySigningKeys ?? [])];
+        if (init.synchronizer === undefined || init.synchronizer.length === 0) {
+            throw new ValidationError("decentralized party creation requires a synchronizer");
+        }
+        else if (init.partyHint === undefined || init.partyHint.length === 0) {
+            throw new ValidationError("decentralized party creation requires a party hint");
+        }
+        else if (owners.length < 2) {
+            throw new ValidationError("decentralized party creation requires at least two unique owner keys");
+        }
+        else if (partySigningKeys.length === 0) {
+            throw new ValidationError("decentralized party creation requires at least one party signing key");
+        }
+        else if (init.ownerThreshold === undefined) {
+            throw new ValidationError("decentralized party creation requires an owner threshold");
+        }
+        else if (init.partySigningThreshold === undefined) {
+            throw new ValidationError("decentralized party creation requires a party signing threshold");
+        }
+        else if (init.ownerThreshold < 1 || init.ownerThreshold > owners.length) {
+            throw new ValidationError("decentralized party owner threshold must be within the owner key count");
+        }
+        else if (init.partySigningThreshold < 1 || init.partySigningThreshold > partySigningKeys.length) {
+            throw new ValidationError("decentralized party signing threshold must be within the party signing key count");
+        }
+        validateUniqueKeys(owners, "owner");
+        validateUniqueKeys(partySigningKeys, "party signing");
+        this.synchronizer = init.synchronizer;
+        this.partyHint = init.partyHint;
+        this.owners = owners.map(cloneKey);
+        this.ownerThreshold = init.ownerThreshold;
+        this.partySigningKeys = partySigningKeys.map(cloneKey);
+        this.partySigningThreshold = init.partySigningThreshold;
+        this.localParticipantObservationOnly = init.localParticipantObservationOnly ?? false;
+        this.otherConfirmingParticipantUids = [...(init.otherConfirmingParticipantUids ?? [])];
+        this.confirmationThreshold = init.confirmationThreshold ?? 0;
+        this.observingParticipantUids = [...(init.observingParticipantUids ?? [])];
+        this.identityProviderId = init.identityProviderId;
+        this.waitForAllocation = init.waitForAllocation;
+        this.userId = init.userId;
+    }
+}
+function cloneKey(value) {
+    return {
+        publicKey: new ExternalPartySigningPublicKey({
+            format: value.publicKey.format,
+            keyData: value.publicKey.keyData,
+            keySpec: value.publicKey.keySpec,
+        }),
+        sign: value.sign,
+    };
+}
+function validateUniqueKeys(values, label) {
+    const fingerprints = values.map((value) => {
+        if (value.publicKey.keyData.length === 0) {
+            throw new ValidationError(`decentralized party ${label} key requires public key material`);
+        }
+        return computeCantonPublicKeyFingerprint(value.publicKey.keyData, value.publicKey.format);
+    });
+    if (new Set(fingerprints).size !== fingerprints.length) {
+        throw new ValidationError(`decentralized party ${label} keys must be unique`);
+    }
+}

package/dist/core/types/requests/create-external-party-request.d.ts

@@ -0,0 +1,42 @@
+import { ExternalPartySignatureFormat } from "../external-party/external-party-signature-format.js";
+import { ExternalPartySigningAlgorithmSpec } from "../external-party/external-party-signing-algorithm-spec.js";
+import { ExternalPartySigningPublicKey } from "../external-party/external-party-signing-public-key.js";
+export type ExternalPartySigningPayloadKind = "topology-transaction" | "multi-hash";
+export interface ExternalPartySigningRequest {
+    readonly payload: Uint8Array;
+    readonly kind: ExternalPartySigningPayloadKind;
+    readonly partyId: string;
+    readonly publicKeyFingerprint: string;
+}
+export interface ExternalPartySigningResult {
+    readonly signature: Uint8Array;
+    readonly format: ExternalPartySignatureFormat;
+    readonly signingAlgorithmSpec: ExternalPartySigningAlgorithmSpec;
+}
+export type ExternalPartySigner = (request: ExternalPartySigningRequest) => Promise<ExternalPartySigningResult>;
+export declare class CreateExternalPartyRequest {
+    readonly synchronizer: string;
+    readonly partyHint: string;
+    readonly publicKey: ExternalPartySigningPublicKey;
+    readonly localParticipantObservationOnly: boolean;
+    readonly otherConfirmingParticipantUids: readonly string[];
+    readonly confirmationThreshold: number;
+    readonly observingParticipantUids: readonly string[];
+    readonly identityProviderId?: string;
+    readonly waitForAllocation?: boolean;
+    readonly userId?: string;
+    readonly sign: ExternalPartySigner;
+    constructor(init: {
+        synchronizer?: string;
+        partyHint?: string;
+        publicKey?: ExternalPartySigningPublicKey;
+        localParticipantObservationOnly?: boolean;
+        otherConfirmingParticipantUids?: readonly string[];
+        confirmationThreshold?: number;
+        observingParticipantUids?: readonly string[];
+        identityProviderId?: string;
+        waitForAllocation?: boolean;
+        userId?: string;
+        sign?: ExternalPartySigner;
+    });
+}

package/dist/core/types/requests/create-external-party-request.js

@@ -0,0 +1,47 @@
+import { ValidationError } from "../../errors/validation-error.js";
+import { ExternalPartySigningPublicKey } from "../external-party/external-party-signing-public-key.js";
+export class CreateExternalPartyRequest {
+    synchronizer;
+    partyHint;
+    publicKey;
+    localParticipantObservationOnly;
+    otherConfirmingParticipantUids;
+    confirmationThreshold;
+    observingParticipantUids;
+    identityProviderId;
+    waitForAllocation;
+    userId;
+    sign;
+    constructor(init) {
+        if (init.synchronizer === undefined || init.synchronizer.length === 0) {
+            throw new ValidationError("external party creation requires a synchronizer");
+        }
+        else if (init.partyHint === undefined || init.partyHint.length === 0) {
+            throw new ValidationError("external party creation requires a party hint");
+        }
+        else if (init.publicKey === undefined || init.publicKey.keyData.length === 0) {
+            throw new ValidationError("external party creation requires public key material");
+        }
+        else if (init.sign === undefined) {
+            throw new ValidationError("external party creation requires a signer");
+        }
+        this.synchronizer = init.synchronizer;
+        this.partyHint = init.partyHint;
+        this.publicKey = new ExternalPartySigningPublicKey({
+            format: init.publicKey.format,
+            keyData: init.publicKey.keyData,
+            keySpec: init.publicKey.keySpec,
+        });
+        this.localParticipantObservationOnly =
+            init.localParticipantObservationOnly ?? false;
+        this.otherConfirmingParticipantUids = [
+            ...(init.otherConfirmingParticipantUids ?? []),
+        ];
+        this.confirmationThreshold = init.confirmationThreshold ?? 0;
+        this.observingParticipantUids = [...(init.observingParticipantUids ?? [])];
+        this.identityProviderId = init.identityProviderId;
+        this.waitForAllocation = init.waitForAllocation;
+        this.userId = init.userId;
+        this.sign = init.sign;
+    }
+}

package/dist/core/types/requests/finalize-decentralized-party-request.d.ts

@@ -0,0 +1,39 @@
+import { PreparedTopologyTransaction } from "../topology/prepared-topology-transaction.js";
+import { ExternalPartySigningResult } from "./create-external-party-request.js";
+export interface PreparedDecentralizedPartySigningRequest {
+    readonly id: string;
+    readonly transactionHash: Uint8Array;
+    readonly payload: Uint8Array;
+    readonly publicKeyFingerprint: string;
+    readonly role: "owner" | "partySigningKey";
+}
+export declare class PreparedDecentralizedParty {
+    readonly synchronizer: string;
+    readonly partyId: string;
+    readonly decentralizedNamespace: string;
+    readonly ownerThreshold: number;
+    readonly partySigningThreshold: number;
+    readonly transactions: readonly PreparedTopologyTransaction[];
+    readonly signingRequests: readonly PreparedDecentralizedPartySigningRequest[];
+    constructor(init: {
+        synchronizer: string;
+        partyId: string;
+        decentralizedNamespace: string;
+        ownerThreshold: number;
+        partySigningThreshold: number;
+        transactions?: readonly PreparedTopologyTransaction[];
+        signingRequests?: readonly PreparedDecentralizedPartySigningRequest[];
+    });
+}
+export interface DecentralizedPartyDetachedSignature {
+    readonly signingRequestId: string;
+    readonly result: ExternalPartySigningResult;
+}
+export declare class FinalizeDecentralizedPartyRequest {
+    readonly prepared: PreparedDecentralizedParty;
+    readonly signatures: readonly DecentralizedPartyDetachedSignature[];
+    constructor(init: {
+        prepared: PreparedDecentralizedParty;
+        signatures?: readonly DecentralizedPartyDetachedSignature[];
+    });
+}

package/dist/core/types/requests/finalize-decentralized-party-request.js

@@ -0,0 +1,42 @@
+import { PreparedTopologyTransaction } from "../topology/prepared-topology-transaction.js";
+export class PreparedDecentralizedParty {
+    synchronizer;
+    partyId;
+    decentralizedNamespace;
+    ownerThreshold;
+    partySigningThreshold;
+    transactions;
+    signingRequests;
+    constructor(init) {
+        this.synchronizer = init.synchronizer;
+        this.partyId = init.partyId;
+        this.decentralizedNamespace = init.decentralizedNamespace;
+        this.ownerThreshold = init.ownerThreshold;
+        this.partySigningThreshold = init.partySigningThreshold;
+        this.transactions = [...(init.transactions ?? [])].map((transaction) => new PreparedTopologyTransaction({
+            serializedTransaction: transaction.serializedTransaction,
+            transactionHash: transaction.transactionHash,
+            proposal: transaction.proposal,
+        }));
+        this.signingRequests = [...(init.signingRequests ?? [])].map((request) => ({
+            ...request,
+            transactionHash: new Uint8Array(request.transactionHash),
+            payload: new Uint8Array(request.payload),
+        }));
+    }
+}
+export class FinalizeDecentralizedPartyRequest {
+    prepared;
+    signatures;
+    constructor(init) {
+        this.prepared = init.prepared;
+        this.signatures = [...(init.signatures ?? [])].map((signature) => ({
+            signingRequestId: signature.signingRequestId,
+            result: {
+                signature: new Uint8Array(signature.result.signature),
+                format: signature.result.format,
+                signingAlgorithmSpec: signature.result.signingAlgorithmSpec,
+            },
+        }));
+    }
+}

package/dist/core/types/requests/get-active-contracts-page-request.d.ts

@@ -1,5 +1,7 @@
 export declare class GetActiveContractsPageRequest {
-    readonly party: string;
+    readonly party?: string;
+    readonly parties?: readonly string[];
+    readonly allParties?: boolean;
     readonly templateId?: string;
     readonly interfaceId?: string;
     readonly includeInterfaceView?: boolean;
@@ -7,8 +9,19 @@ export declare class GetActiveContractsPageRequest {
     readonly activeAtOffset?: string;
     readonly maxPageSize?: number;
     readonly pageToken?: Uint8Array;
-    constructor(init: {
+    constructor(init: ({
         party: string;
+        parties?: never;
+        allParties?: never;
+    } | {
+        party?: never;
+        parties: readonly string[];
+        allParties?: never;
+    } | {
+        party?: never;
+        parties?: never;
+        allParties: true;
+    }) & {
         templateId?: string;
         interfaceId?: string;
         includeInterfaceView?: boolean;

package/dist/core/types/requests/get-active-contracts-page-request.js

@@ -1,5 +1,7 @@
 export class GetActiveContractsPageRequest {
     party;
+    parties;
+    allParties;
     templateId;
     interfaceId;
     includeInterfaceView;
@@ -9,6 +11,8 @@ export class GetActiveContractsPageRequest {
     pageToken;
     constructor(init) {
         this.party = init.party;
+        this.parties = init.parties;
+        this.allParties = init.allParties;
         this.templateId = init.templateId;
         this.interfaceId = init.interfaceId;
         this.includeInterfaceView = init.includeInterfaceView;

package/dist/core/types/requests/submit-command-request.d.ts

@@ -1,11 +1,13 @@
 import { LedgerCommand } from "../commands/ledger-command.js";
 export declare class SubmitCommandRequest {
     readonly applicationId: string;
+    readonly userId?: string;
     readonly actAs: readonly string[];
     readonly readAs: readonly string[];
     readonly command: LedgerCommand;
     constructor(init: {
         applicationId: string;
+        userId?: string;
         actAs: readonly string[];
         readAs?: readonly string[];
         command: LedgerCommand;

package/dist/core/types/requests/submit-command-request.js

@@ -1,6 +1,7 @@
 import { ValidationError } from "../../errors/validation-error.js";
 export class SubmitCommandRequest {
     applicationId;
+    userId;
     actAs;
     readAs;
     command;
@@ -9,6 +10,7 @@ export class SubmitCommandRequest {
             throw new ValidationError("submit requests require at least one actAs party");
         }
         this.applicationId = init.applicationId;
+        this.userId = init.userId;
         this.actAs = init.actAs;
         this.readAs = init.readAs ?? [];
         this.command = init.command;

package/dist/core/types/topology/topology-signature-format.d.ts

@@ -1,3 +1,4 @@
 export declare enum TopologySignatureFormat {
-    ed25519 = "ed25519"
+    ed25519 = "ed25519",
+    ecDsaSha256 = "ecDsaSha256"
 }

package/dist/core/types/topology/topology-signature-format.js

@@ -1,4 +1,5 @@
 export var TopologySignatureFormat;
 (function (TopologySignatureFormat) {
     TopologySignatureFormat["ed25519"] = "ed25519";
+    TopologySignatureFormat["ecDsaSha256"] = "ecDsaSha256";
 })(TopologySignatureFormat || (TopologySignatureFormat = {}));

package/dist/daml-lf/container/dar-archive-entry.d.ts

@@ -0,0 +1,8 @@
+export declare class DarArchiveEntry {
+    readonly path: string;
+    readonly bytes: Uint8Array;
+    constructor(init: {
+        path: string;
+        bytes: Uint8Array;
+    });
+}

package/dist/daml-lf/container/dar-archive-entry.js

@@ -0,0 +1,8 @@
+export class DarArchiveEntry {
+    path;
+    bytes;
+    constructor(init) {
+        this.path = init.path;
+        this.bytes = init.bytes;
+    }
+}

package/dist/daml-lf/container/dar-archive-loader.js

@@ -1,8 +1,10 @@
 import { strFromU8, unzipSync } from "fflate";
 import { DamlLfArchiveException } from "../errors/daml-lf-archive.exception.js";
 import { DarArchive } from "./dar-archive.js";
+import { DarArchiveEntry } from "./dar-archive-entry.js";
 import { DarManifest } from "./dar-manifest.js";
 import { DarPackageEntry } from "./dar-package-entry.js";
+import { DarSourceFileEntry } from "./dar-source-file-entry.js";
 export class DarArchiveLoader {
     async loadDarOrThrowAsync(archiveBytes) {
         try {
@@ -12,20 +14,32 @@ export class DarArchiveLoader {
                 throw new DamlLfArchiveException("dar archive does not contain META-INF/MANIFEST.MF");
             }
             const manifest = this.parseManifestOrThrow(strFromU8(manifestBytes));
+            const entries = Object.entries(archiveEntries).map(([path, bytes]) => new DarArchiveEntry({
+                path,
+                bytes,
+            }));
             const packageEntries = Object.entries(archiveEntries)
                 .filter(([path]) => path.endsWith(".dalf"))
                 .map(([path, bytes]) => new DarPackageEntry({
                 path,
                 bytes,
             }));
+            const sourceFiles = Object.entries(archiveEntries)
+                .filter(([path]) => path.endsWith(".daml"))
+                .map(([path, bytes]) => new DarSourceFileEntry({
+                path,
+                content: strFromU8(bytes),
+            }));
             const mainPackageEntry = packageEntries.find((entry) => entry.path === manifest.mainDalfPath);
             if (mainPackageEntry === undefined) {
                 throw new DamlLfArchiveException(`dar archive does not contain the main dalf entry '${manifest.mainDalfPath}'`);
             }
             return new DarArchive({
+                entries,
                 manifest,
                 mainPackageEntry,
                 packageEntries,
+                sourceFiles,
             });
         }
         catch (error) {

package/dist/daml-lf/container/dar-archive.d.ts

@@ -1,12 +1,18 @@
 import { DarManifest } from "./dar-manifest.js";
+import { DarArchiveEntry } from "./dar-archive-entry.js";
 import { DarPackageEntry } from "./dar-package-entry.js";
+import { DarSourceFileEntry } from "./dar-source-file-entry.js";
 export declare class DarArchive {
+    readonly entries: readonly DarArchiveEntry[];
     readonly manifest: DarManifest;
     readonly mainPackageEntry: DarPackageEntry;
     readonly packageEntries: readonly DarPackageEntry[];
+    readonly sourceFiles: readonly DarSourceFileEntry[];
     constructor(init: {
+        entries: readonly DarArchiveEntry[];
         manifest: DarManifest;
         mainPackageEntry: DarPackageEntry;
         packageEntries: readonly DarPackageEntry[];
+        sourceFiles: readonly DarSourceFileEntry[];
     });
 }

package/dist/daml-lf/container/dar-archive.js

@@ -1,10 +1,14 @@
 export class DarArchive {
+    entries;
     manifest;
     mainPackageEntry;
     packageEntries;
+    sourceFiles;
     constructor(init) {
+        this.entries = init.entries;
         this.manifest = init.manifest;
         this.mainPackageEntry = init.mainPackageEntry;
         this.packageEntries = init.packageEntries;
+        this.sourceFiles = init.sourceFiles;
     }
 }

package/dist/daml-lf/container/dar-source-bundle-loader.d.ts

@@ -0,0 +1,5 @@
+import { DarSourceBundle } from "./dar-source-bundle.js";
+export declare class DarSourceBundleLoader {
+    private readonly archiveLoader;
+    loadSourceBundleOrThrowAsync(archiveBytes: Uint8Array): Promise<DarSourceBundle>;
+}

package/dist/daml-lf/container/dar-source-bundle-loader.js

@@ -0,0 +1,33 @@
+import { strFromU8 } from "fflate";
+import { DamlLfArchiveException } from "../errors/daml-lf-archive.exception.js";
+import { DarArchiveLoader } from "./dar-archive-loader.js";
+import { DarSourceBundle, } from "./dar-source-bundle.js";
+export class DarSourceBundleLoader {
+    archiveLoader = new DarArchiveLoader();
+    async loadSourceBundleOrThrowAsync(archiveBytes) {
+        const archive = await this.archiveLoader.loadDarOrThrowAsync(archiveBytes);
+        const metadataEntry = archive.entries.find((entry) => entry.path === "debug/source-map.json");
+        if (metadataEntry === undefined) {
+            throw new DamlLfArchiveException("dar archive does not contain debug/source-map.json");
+        }
+        const metadata = JSON.parse(strFromU8(metadataEntry.bytes));
+        if (!Array.isArray(metadata.executables)) {
+            throw new DamlLfArchiveException("dar source-map metadata must define an executables array");
+        }
+        return new DarSourceBundle({
+            sourceFiles: archive.sourceFiles,
+            metadata: {
+                packageId: typeof metadata.packageId === "string"
+                    ? metadata.packageId
+                    : undefined,
+                importedPackages: Array.isArray(metadata.importedPackages)
+                    ? metadata.importedPackages.filter((entry) => typeof entry === "string")
+                    : [],
+                executables: metadata.executables,
+                expressionLocations: Array.isArray(metadata.expressionLocations)
+                    ? metadata.expressionLocations
+                    : [],
+            },
+        });
+    }
+}

package/dist/daml-lf/container/dar-source-bundle.d.ts

@@ -0,0 +1,45 @@
+import { DarSourceFileEntry } from "./dar-source-file-entry.js";
+export interface DarSourceBundleMetadataExecutable {
+    packageId: string;
+    moduleName: string;
+    definitionName: string;
+    path: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    precision?: "exact" | "fallback";
+    entrypointKind?: "create" | "exercise";
+    templateName?: string;
+    choiceName?: string;
+    choiceArgumentFieldName?: string;
+}
+export interface DarSourceBundleMetadataExpressionLocation {
+    packageId: string;
+    moduleName: string;
+    definitionName: string;
+    expressionPath: readonly number[];
+    path: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export declare class DarSourceBundle {
+    readonly sourceFiles: readonly DarSourceFileEntry[];
+    readonly metadata: {
+        packageId?: string;
+        importedPackages?: readonly string[];
+        executables: readonly DarSourceBundleMetadataExecutable[];
+        expressionLocations: readonly DarSourceBundleMetadataExpressionLocation[];
+    };
+    constructor(init: {
+        sourceFiles: readonly DarSourceFileEntry[];
+        metadata: {
+            packageId?: string;
+            importedPackages?: readonly string[];
+            executables: readonly DarSourceBundleMetadataExecutable[];
+            expressionLocations?: readonly DarSourceBundleMetadataExpressionLocation[];
+        };
+    });
+}

package/dist/daml-lf/container/dar-source-bundle.js

@@ -0,0 +1,11 @@
+export class DarSourceBundle {
+    sourceFiles;
+    metadata;
+    constructor(init) {
+        this.sourceFiles = init.sourceFiles;
+        this.metadata = {
+            ...init.metadata,
+            expressionLocations: init.metadata.expressionLocations ?? [],
+        };
+    }
+}

package/dist/daml-lf/container/dar-source-file-entry.d.ts

@@ -0,0 +1,8 @@
+export declare class DarSourceFileEntry {
+    readonly path: string;
+    readonly content: string;
+    constructor(init: {
+        path: string;
+        content: string;
+    });
+}