@distrohelena/canton-typescript-sdk 0.1.0

package/dist/daml-lf/decoding/archive-payload-decoder.js

@@ -0,0 +1,57 @@
+import { Archive, ArchivePayload, } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf.js";
+import { DamlLfDecodeException } from "../errors/daml-lf-decode.exception.js";
+import { DamlLfVersionNotSupportedException } from "../errors/daml-lf-version-not-supported.exception.js";
+import { ArchivePayloadEnvelope } from "./archive-payload-envelope.js";
+import { DamlLfLanguageVersion } from "./daml-lf-language-version.js";
+export class ArchivePayloadDecoder {
+    static decodeArchiveOrThrow(archiveBytes) {
+        try {
+            const archive = Archive.fromBinary(archiveBytes);
+            const payload = ArchivePayload.fromBinary(archive.payload);
+            const languageVersion = ArchivePayloadDecoder.getLanguageVersionOrThrow(payload);
+            const packagePayload = ArchivePayloadDecoder.getPackagePayloadOrThrow(payload);
+            return new ArchivePayloadEnvelope({
+                packageId: archive.hash,
+                languageVersion,
+                packagePayload,
+            });
+        }
+        catch (error) {
+            if (error instanceof DamlLfVersionNotSupportedException ||
+                error instanceof DamlLfDecodeException) {
+                throw error;
+            }
+            throw new DamlLfDecodeException(error instanceof Error
+                ? error.message
+                : "failed to decode daml lf archive payload");
+        }
+    }
+    static getLanguageVersionOrThrow(payload) {
+        switch (payload.sum.oneofKind) {
+            case "damlLf2":
+                return new DamlLfLanguageVersion({
+                    major: 2,
+                    minor: payload.minor,
+                    patch: payload.patch,
+                });
+            case "damlLf1":
+                return new DamlLfLanguageVersion({
+                    major: 1,
+                    minor: payload.minor,
+                    patch: payload.patch,
+                });
+            default:
+                throw new DamlLfVersionNotSupportedException("daml lf archive payload does not declare a supported package kind");
+        }
+    }
+    static getPackagePayloadOrThrow(payload) {
+        switch (payload.sum.oneofKind) {
+            case "damlLf2":
+                return payload.sum.damlLf2;
+            case "damlLf1":
+                throw new DamlLfVersionNotSupportedException("daml lf 1.x is not supported yet");
+            default:
+                throw new DamlLfVersionNotSupportedException("daml lf archive payload does not contain a package body");
+        }
+    }
+}

package/dist/daml-lf/decoding/archive-payload-envelope.d.ts

@@ -0,0 +1,11 @@
+import { DamlLfLanguageVersion } from "./daml-lf-language-version.js";
+export declare class ArchivePayloadEnvelope {
+    readonly packageId: string;
+    readonly languageVersion: DamlLfLanguageVersion;
+    readonly packagePayload: Uint8Array;
+    constructor(init: {
+        packageId: string;
+        languageVersion: DamlLfLanguageVersion;
+        packagePayload: Uint8Array;
+    });
+}

package/dist/daml-lf/decoding/archive-payload-envelope.js

@@ -0,0 +1,10 @@
+export class ArchivePayloadEnvelope {
+    packageId;
+    languageVersion;
+    packagePayload;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.languageVersion = init.languageVersion;
+        this.packagePayload = init.packagePayload;
+    }
+}

package/dist/daml-lf/decoding/daml-lf-language-version.d.ts

@@ -0,0 +1,11 @@
+export declare class DamlLfLanguageVersion {
+    readonly major: number;
+    readonly minor: string;
+    readonly patch: number;
+    constructor(init: {
+        major: number;
+        minor: string;
+        patch: number;
+    });
+    toString(): string;
+}

package/dist/daml-lf/decoding/daml-lf-language-version.js

@@ -0,0 +1,13 @@
+export class DamlLfLanguageVersion {
+    major;
+    minor;
+    patch;
+    constructor(init) {
+        this.major = init.major;
+        this.minor = init.minor;
+        this.patch = init.patch;
+    }
+    toString() {
+        return `${this.major}.${this.minor}`;
+    }
+}

package/dist/daml-lf/decoding/lf-2-package-decoder.d.ts

@@ -0,0 +1,7 @@
+import { Package as LfArchivePackage } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js";
+import { DamlLfLanguageVersion } from "./daml-lf-language-version.js";
+import { IPackageDecoder } from "./package-decoder.interface.js";
+export declare class Lf2PackageDecoder implements IPackageDecoder<LfArchivePackage> {
+    canDecode(languageVersion: DamlLfLanguageVersion): boolean;
+    decodePackageOrThrow(packageBytes: Uint8Array): LfArchivePackage;
+}

package/dist/daml-lf/decoding/lf-2-package-decoder.js

@@ -0,0 +1,17 @@
+import { Package as LfArchivePackage } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js";
+import { DamlLfDecodeException } from "../errors/daml-lf-decode.exception.js";
+export class Lf2PackageDecoder {
+    canDecode(languageVersion) {
+        return languageVersion.major === 2;
+    }
+    decodePackageOrThrow(packageBytes) {
+        try {
+            return LfArchivePackage.fromBinary(packageBytes);
+        }
+        catch (error) {
+            throw new DamlLfDecodeException(error instanceof Error
+                ? error.message
+                : "failed to decode daml lf 2.x package");
+        }
+    }
+}

package/dist/daml-lf/decoding/package-decoder-registry.d.ts

@@ -0,0 +1,8 @@
+import { Package as LfArchivePackage } from "../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js";
+import { DamlLfLanguageVersion } from "./daml-lf-language-version.js";
+import { IPackageDecoder } from "./package-decoder.interface.js";
+export declare class PackageDecoderRegistry {
+    private readonly decoders;
+    constructor(decoders?: readonly IPackageDecoder<LfArchivePackage>[]);
+    decodePackageOrThrow(packageBytes: Uint8Array, languageVersion: DamlLfLanguageVersion): LfArchivePackage;
+}

package/dist/daml-lf/decoding/package-decoder-registry.js

@@ -0,0 +1,17 @@
+import { DamlLfVersionNotSupportedException } from "../errors/daml-lf-version-not-supported.exception.js";
+import { Lf2PackageDecoder } from "./lf-2-package-decoder.js";
+export class PackageDecoderRegistry {
+    decoders;
+    constructor(decoders = [
+        new Lf2PackageDecoder(),
+    ]) {
+        this.decoders = decoders;
+    }
+    decodePackageOrThrow(packageBytes, languageVersion) {
+        const decoder = this.decoders.find((candidate) => candidate.canDecode(languageVersion));
+        if (decoder === undefined) {
+            throw new DamlLfVersionNotSupportedException(`daml lf ${languageVersion.toString()} is not supported yet`);
+        }
+        return decoder.decodePackageOrThrow(packageBytes);
+    }
+}

package/dist/daml-lf/decoding/package-decoder.interface.d.ts

@@ -0,0 +1,5 @@
+import { DamlLfLanguageVersion } from "./daml-lf-language-version.js";
+export interface IPackageDecoder<TPackage> {
+    canDecode(languageVersion: DamlLfLanguageVersion): boolean;
+    decodePackageOrThrow(packageBytes: Uint8Array): TPackage;
+}

package/dist/daml-lf/decoding/package-decoder.interface.js

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

package/dist/daml-lf/errors/daml-lf-archive.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class DamlLfArchiveException extends Error {
+    constructor(message: string);
+}

package/dist/daml-lf/errors/daml-lf-archive.exception.js

@@ -0,0 +1,6 @@
+export class DamlLfArchiveException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlLfArchiveException";
+    }
+}

package/dist/daml-lf/errors/daml-lf-decode.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class DamlLfDecodeException extends Error {
+    constructor(message: string);
+}

package/dist/daml-lf/errors/daml-lf-decode.exception.js

@@ -0,0 +1,6 @@
+export class DamlLfDecodeException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlLfDecodeException";
+    }
+}

package/dist/daml-lf/errors/daml-lf-resolution.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class DamlLfResolutionException extends Error {
+    constructor(message: string);
+}

package/dist/daml-lf/errors/daml-lf-resolution.exception.js

@@ -0,0 +1,6 @@
+export class DamlLfResolutionException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlLfResolutionException";
+    }
+}

package/dist/daml-lf/errors/daml-lf-semantic.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class DamlLfSemanticException extends Error {
+    constructor(message: string);
+}

package/dist/daml-lf/errors/daml-lf-semantic.exception.js

@@ -0,0 +1,6 @@
+export class DamlLfSemanticException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlLfSemanticException";
+    }
+}

package/dist/daml-lf/errors/daml-lf-version-not-supported.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class DamlLfVersionNotSupportedException extends Error {
+    constructor(message: string);
+}

package/dist/daml-lf/errors/daml-lf-version-not-supported.exception.js

@@ -0,0 +1,6 @@
+export class DamlLfVersionNotSupportedException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlLfVersionNotSupportedException";
+    }
+}

package/dist/daml-lf/index.d.ts

@@ -0,0 +1,26 @@
+export { DamlLfArchiveException } from "./errors/daml-lf-archive.exception.js";
+export { DamlLfDecodeException } from "./errors/daml-lf-decode.exception.js";
+export { DamlLfResolutionException } from "./errors/daml-lf-resolution.exception.js";
+export { DamlLfSemanticException } from "./errors/daml-lf-semantic.exception.js";
+export { DamlLfVersionNotSupportedException } from "./errors/daml-lf-version-not-supported.exception.js";
+export { DamlLfCompilation } from "./daml-lf-compilation.js";
+export { DamlLfPackageLoader, DamlLfPackageLoadResult } from "./daml-lf-package-loader.js";
+export { DamlLfWorkspace } from "./daml-lf-workspace.js";
+export { DarArchiveLoader } from "./container/dar-archive-loader.js";
+export { DamlLfBuiltinDispatch } from "./interpreter/daml-lf-builtin-dispatch.js";
+export { DamlLfInterpreterScaffold } from "./interpreter/daml-lf-interpreter-scaffold.js";
+export { DamlLfBuiltinType } from "./model/daml-lf-builtin-type.js";
+export { DamlLfChoice } from "./model/daml-lf-choice.js";
+export { DamlLfChoiceParameter } from "./model/daml-lf-choice-parameter.js";
+export { DamlLfDataType } from "./model/daml-lf-data-type.js";
+export { DamlLfField } from "./model/daml-lf-field.js";
+export { DamlLfModule } from "./model/daml-lf-module.js";
+export { DamlLfNodeKind } from "./model/daml-lf-node-kind.js";
+export { DamlLfPackage } from "./model/daml-lf-package.js";
+export { DamlLfTemplate } from "./model/daml-lf-template.js";
+export { DamlLfTemplateId } from "./model/daml-lf-template-id.js";
+export { DamlLfType } from "./model/daml-lf-type.js";
+export { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
+export { ModuleReference } from "./model/module-reference.js";
+export { DamlLfSemanticModel } from "./semantics/daml-lf-semantic-model.js";
+export { TypeConReference } from "./model/type-con-reference.js";

package/dist/daml-lf/index.js

@@ -0,0 +1,26 @@
+export { DamlLfArchiveException } from "./errors/daml-lf-archive.exception.js";
+export { DamlLfDecodeException } from "./errors/daml-lf-decode.exception.js";
+export { DamlLfResolutionException } from "./errors/daml-lf-resolution.exception.js";
+export { DamlLfSemanticException } from "./errors/daml-lf-semantic.exception.js";
+export { DamlLfVersionNotSupportedException } from "./errors/daml-lf-version-not-supported.exception.js";
+export { DamlLfCompilation } from "./daml-lf-compilation.js";
+export { DamlLfPackageLoader, DamlLfPackageLoadResult } from "./daml-lf-package-loader.js";
+export { DamlLfWorkspace } from "./daml-lf-workspace.js";
+export { DarArchiveLoader } from "./container/dar-archive-loader.js";
+export { DamlLfBuiltinDispatch } from "./interpreter/daml-lf-builtin-dispatch.js";
+export { DamlLfInterpreterScaffold } from "./interpreter/daml-lf-interpreter-scaffold.js";
+export { DamlLfBuiltinType } from "./model/daml-lf-builtin-type.js";
+export { DamlLfChoice } from "./model/daml-lf-choice.js";
+export { DamlLfChoiceParameter } from "./model/daml-lf-choice-parameter.js";
+export { DamlLfDataType } from "./model/daml-lf-data-type.js";
+export { DamlLfField } from "./model/daml-lf-field.js";
+export { DamlLfModule } from "./model/daml-lf-module.js";
+export { DamlLfNodeKind } from "./model/daml-lf-node-kind.js";
+export { DamlLfPackage } from "./model/daml-lf-package.js";
+export { DamlLfTemplate } from "./model/daml-lf-template.js";
+export { DamlLfTemplateId } from "./model/daml-lf-template-id.js";
+export { DamlLfType } from "./model/daml-lf-type.js";
+export { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
+export { ModuleReference } from "./model/module-reference.js";
+export { DamlLfSemanticModel } from "./semantics/daml-lf-semantic-model.js";
+export { TypeConReference } from "./model/type-con-reference.js";

package/dist/daml-lf/interpreter/daml-lf-builtin-dispatch.d.ts

@@ -0,0 +1,2 @@
+export declare class DamlLfBuiltinDispatch {
+}

package/dist/daml-lf/interpreter/daml-lf-builtin-dispatch.js

@@ -0,0 +1,2 @@
+export class DamlLfBuiltinDispatch {
+}

package/dist/daml-lf/interpreter/daml-lf-evaluation-context.interface.d.ts

@@ -0,0 +1,4 @@
+import { DamlLfCompilation } from "../daml-lf-compilation.js";
+export interface IDamlLfEvaluationContext {
+    readonly compilation: DamlLfCompilation;
+}

package/dist/daml-lf/interpreter/daml-lf-evaluation-context.interface.js

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

package/dist/daml-lf/interpreter/daml-lf-interpreter-scaffold.d.ts

@@ -0,0 +1,9 @@
+import { DamlLfCompilation } from "../daml-lf-compilation.js";
+import { DamlLfBuiltinDispatch } from "./daml-lf-builtin-dispatch.js";
+export declare class DamlLfInterpreterScaffold {
+    private readonly compilation;
+    private readonly builtinDispatch;
+    constructor(compilation: DamlLfCompilation);
+    getCompilation(): DamlLfCompilation;
+    getBuiltinDispatch(): DamlLfBuiltinDispatch;
+}

package/dist/daml-lf/interpreter/daml-lf-interpreter-scaffold.js

@@ -0,0 +1,15 @@
+import { DamlLfBuiltinDispatch } from "./daml-lf-builtin-dispatch.js";
+export class DamlLfInterpreterScaffold {
+    compilation;
+    builtinDispatch = new DamlLfBuiltinDispatch();
+    constructor(compilation) {
+        this.compilation = compilation;
+        void this.compilation;
+    }
+    getCompilation() {
+        return this.compilation;
+    }
+    getBuiltinDispatch() {
+        return this.builtinDispatch;
+    }
+}

package/dist/daml-lf/interpreter/daml-lf-runtime-value.d.ts

@@ -0,0 +1,3 @@
+export interface IDamlLfRuntimeValue {
+    readonly kind: string;
+}

package/dist/daml-lf/interpreter/daml-lf-runtime-value.js

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

package/dist/daml-lf/model/daml-lf-builtin-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum DamlLfBuiltinType {
+    text = "text",
+    unknown = "unknown"
+}

package/dist/daml-lf/model/daml-lf-builtin-type.js

@@ -0,0 +1,5 @@
+export var DamlLfBuiltinType;
+(function (DamlLfBuiltinType) {
+    DamlLfBuiltinType["text"] = "text";
+    DamlLfBuiltinType["unknown"] = "unknown";
+})(DamlLfBuiltinType || (DamlLfBuiltinType = {}));

package/dist/daml-lf/model/daml-lf-choice-parameter.d.ts

@@ -0,0 +1,11 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+import { DamlLfType } from "./daml-lf-type.js";
+export declare class DamlLfChoiceParameter {
+    readonly nodeKind = DamlLfNodeKind.choiceParameter;
+    readonly name: string;
+    readonly type: DamlLfType;
+    constructor(init: {
+        name: string;
+        type: DamlLfType;
+    });
+}

package/dist/daml-lf/model/daml-lf-choice-parameter.js

@@ -0,0 +1,10 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfChoiceParameter {
+    nodeKind = DamlLfNodeKind.choiceParameter;
+    name;
+    type;
+    constructor(init) {
+        this.name = init.name;
+        this.type = init.type;
+    }
+}

package/dist/daml-lf/model/daml-lf-choice.d.ts

@@ -0,0 +1,16 @@
+import { DamlLfChoiceParameter } from "./daml-lf-choice-parameter.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+import { DamlLfType } from "./daml-lf-type.js";
+export declare class DamlLfChoice {
+    readonly nodeKind = DamlLfNodeKind.choice;
+    readonly name: string;
+    readonly consuming: boolean;
+    readonly parameter: DamlLfChoiceParameter;
+    readonly returnType: DamlLfType;
+    constructor(init: {
+        name: string;
+        parameter: DamlLfChoiceParameter;
+        consuming?: boolean;
+        returnType?: DamlLfType;
+    });
+}

package/dist/daml-lf/model/daml-lf-choice.js

@@ -0,0 +1,14 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfChoice {
+    nodeKind = DamlLfNodeKind.choice;
+    name;
+    consuming;
+    parameter;
+    returnType;
+    constructor(init) {
+        this.name = init.name;
+        this.parameter = init.parameter;
+        this.consuming = init.consuming ?? true;
+        this.returnType = init.returnType ?? init.parameter.type;
+    }
+}

package/dist/daml-lf/model/daml-lf-data-type.d.ts

@@ -0,0 +1,11 @@
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfField } from "./daml-lf-field.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export declare class DamlLfDataType extends DamlLfDefinition {
+    readonly nodeKind = DamlLfNodeKind.dataType;
+    readonly fields: readonly DamlLfField[];
+    constructor(init: {
+        name: string;
+        fields: readonly DamlLfField[];
+    });
+}

package/dist/daml-lf/model/daml-lf-data-type.js

@@ -0,0 +1,12 @@
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfDataType extends DamlLfDefinition {
+    nodeKind = DamlLfNodeKind.dataType;
+    fields;
+    constructor(init) {
+        super({
+            name: init.name,
+        });
+        this.fields = init.fields;
+    }
+}

package/dist/daml-lf/model/daml-lf-definition.d.ts

@@ -0,0 +1,8 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export declare abstract class DamlLfDefinition {
+    abstract readonly nodeKind: DamlLfNodeKind;
+    readonly name: string;
+    protected constructor(init: {
+        name: string;
+    });
+}

package/dist/daml-lf/model/daml-lf-definition.js

@@ -0,0 +1,6 @@
+export class DamlLfDefinition {
+    name;
+    constructor(init) {
+        this.name = init.name;
+    }
+}

package/dist/daml-lf/model/daml-lf-expression.d.ts

@@ -0,0 +1,8 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export declare class DamlLfExpression {
+    readonly nodeKind = DamlLfNodeKind.expression;
+    readonly textLiteral?: string;
+    constructor(init: {
+        textLiteral?: string;
+    });
+}

package/dist/daml-lf/model/daml-lf-expression.js

@@ -0,0 +1,8 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfExpression {
+    nodeKind = DamlLfNodeKind.expression;
+    textLiteral;
+    constructor(init) {
+        this.textLiteral = init.textLiteral;
+    }
+}

package/dist/daml-lf/model/daml-lf-field.d.ts

@@ -0,0 +1,9 @@
+import { DamlLfType } from "./daml-lf-type.js";
+export declare class DamlLfField {
+    readonly name: string;
+    readonly type: DamlLfType;
+    constructor(init: {
+        name: string;
+        type: DamlLfType;
+    });
+}

package/dist/daml-lf/model/daml-lf-field.js

@@ -0,0 +1,8 @@
+export class DamlLfField {
+    name;
+    type;
+    constructor(init) {
+        this.name = init.name;
+        this.type = init.type;
+    }
+}

package/dist/daml-lf/model/daml-lf-module.d.ts

@@ -0,0 +1,11 @@
+import { DamlLfDefinition } from "./daml-lf-definition.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export declare class DamlLfModule {
+    readonly nodeKind = DamlLfNodeKind.module;
+    readonly name: string;
+    readonly definitions: readonly DamlLfDefinition[];
+    constructor(init: {
+        name: string;
+        definitions: readonly DamlLfDefinition[];
+    });
+}

package/dist/daml-lf/model/daml-lf-module.js

@@ -0,0 +1,10 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfModule {
+    nodeKind = DamlLfNodeKind.module;
+    name;
+    definitions;
+    constructor(init) {
+        this.name = init.name;
+        this.definitions = init.definitions;
+    }
+}

package/dist/daml-lf/model/daml-lf-node-kind.d.ts

@@ -0,0 +1,11 @@
+export declare enum DamlLfNodeKind {
+    package = "package",
+    module = "module",
+    dataType = "dataType",
+    template = "template",
+    choice = "choice",
+    choiceParameter = "choiceParameter",
+    valueDefinition = "valueDefinition",
+    type = "type",
+    expression = "expression"
+}

package/dist/daml-lf/model/daml-lf-node-kind.js

@@ -0,0 +1,12 @@
+export var DamlLfNodeKind;
+(function (DamlLfNodeKind) {
+    DamlLfNodeKind["package"] = "package";
+    DamlLfNodeKind["module"] = "module";
+    DamlLfNodeKind["dataType"] = "dataType";
+    DamlLfNodeKind["template"] = "template";
+    DamlLfNodeKind["choice"] = "choice";
+    DamlLfNodeKind["choiceParameter"] = "choiceParameter";
+    DamlLfNodeKind["valueDefinition"] = "valueDefinition";
+    DamlLfNodeKind["type"] = "type";
+    DamlLfNodeKind["expression"] = "expression";
+})(DamlLfNodeKind || (DamlLfNodeKind = {}));

package/dist/daml-lf/model/daml-lf-package.d.ts

@@ -0,0 +1,18 @@
+import { DamlLfLanguageVersion } from "../decoding/daml-lf-language-version.js";
+import { DamlLfModule } from "./daml-lf-module.js";
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export declare class DamlLfPackage {
+    readonly nodeKind = DamlLfNodeKind.package;
+    readonly packageId: string;
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly languageVersion: DamlLfLanguageVersion;
+    readonly modules: readonly DamlLfModule[];
+    constructor(init: {
+        packageId?: string;
+        packageName: string;
+        packageVersion: string;
+        languageVersion: DamlLfLanguageVersion;
+        modules: readonly DamlLfModule[];
+    });
+}

package/dist/daml-lf/model/daml-lf-package.js

@@ -0,0 +1,16 @@
+import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export class DamlLfPackage {
+    nodeKind = DamlLfNodeKind.package;
+    packageId;
+    packageName;
+    packageVersion;
+    languageVersion;
+    modules;
+    constructor(init) {
+        this.packageId = init.packageId ?? "";
+        this.packageName = init.packageName;
+        this.packageVersion = init.packageVersion;
+        this.languageVersion = init.languageVersion;
+        this.modules = init.modules;
+    }
+}

package/dist/daml-lf/model/daml-lf-template-id.d.ts

@@ -0,0 +1,12 @@
+import { TypeConReference } from "./type-con-reference.js";
+export declare class DamlLfTemplateId {
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly templateName: string;
+    constructor(init: {
+        packageId: string;
+        moduleName: string;
+        templateName: string;
+    });
+    toTypeConReference(): TypeConReference;
+}

package/dist/daml-lf/model/daml-lf-template-id.js

@@ -0,0 +1,18 @@
+import { TypeConReference } from "./type-con-reference.js";
+export class DamlLfTemplateId {
+    packageId;
+    moduleName;
+    templateName;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.templateName = init.templateName;
+    }
+    toTypeConReference() {
+        return new TypeConReference({
+            packageId: this.packageId,
+            moduleName: this.moduleName,
+            name: this.templateName,
+        });
+    }
+}