@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/daml-interface/emission-model/generated-daml-interface-project.js

@@ -4,11 +4,60 @@ export class GeneratedDamlInterfaceProject {
     supportFiles;
     registryFile;
     indexFile;
+    /** Every non-spec module emitted by this project. */
+    productionFiles;
+    /** Runnable specs, each colocated with exactly one production module. */
+    specFiles;
     constructor(init) {
-        this.templateFiles = init.templateFiles;
-        this.namedTypeFiles = init.namedTypeFiles ?? [];
-        this.supportFiles = init.supportFiles ?? [];
-        this.registryFile = init.registryFile;
-        this.indexFile = init.indexFile;
+        const templateFiles = [...init.templateFiles];
+        const namedTypeFiles = [...(init.namedTypeFiles ?? [])];
+        const supportFiles = [...(init.supportFiles ?? [])];
+        const registryFile = init.registryFile;
+        const indexFile = init.indexFile;
+        const productionFiles = [
+            ...templateFiles,
+            ...namedTypeFiles,
+            ...supportFiles,
+            ...(registryFile === undefined ? [] : [registryFile]),
+            ...(indexFile === undefined ? [] : [indexFile]),
+        ];
+        const specFiles = [...(init.specFiles ?? [])];
+        this.validateFilesOrThrow(productionFiles, specFiles);
+        this.templateFiles = Object.freeze(templateFiles);
+        this.namedTypeFiles = Object.freeze(namedTypeFiles);
+        this.supportFiles = Object.freeze(supportFiles);
+        this.registryFile = registryFile;
+        this.indexFile = indexFile;
+        this.productionFiles = Object.freeze(productionFiles);
+        this.specFiles = Object.freeze(specFiles);
+    }
+    validateFilesOrThrow(productionFiles, specFiles) {
+        const productionPaths = new Set();
+        for (const file of productionFiles) {
+            if (file.path.endsWith(".spec.ts")) {
+                throw new Error(`Generated production file path must not end in .spec.ts: ${file.path}`);
+            }
+            else if (!file.path.endsWith(".ts")) {
+                throw new Error(`Generated production file path must end in .ts: ${file.path}`);
+            }
+            else if (productionPaths.has(file.path)) {
+                throw new Error(`Duplicate production file path: ${file.path}`);
+            }
+            productionPaths.add(file.path);
+        }
+        const specPaths = new Set();
+        for (const specFile of specFiles) {
+            if (!productionPaths.has(specFile.productionPath)) {
+                throw new Error(`Generated spec references a production path that does not exist: ${specFile.productionPath}`);
+            }
+            const expectedPath = specFile.productionPath.replace(/\.ts$/, ".spec.ts");
+            if (specFile.path !== expectedPath) {
+                throw new Error(`Generated spec path must be the sibling .spec.ts file for ${specFile.productionPath}: ${specFile.path}`);
+            }
+            else if (specPaths.has(specFile.path)) {
+                throw new Error(`Duplicate generated spec file path: ${specFile.path}`);
+            }
+            specPaths.add(specFile.path);
+        }
     }
 }

package/dist/daml-interface/emission-model/generated-spec-file.d.ts

@@ -0,0 +1,7 @@
+/** A runnable Node test generated beside one production DAML module. */
+export declare class GeneratedSpecFile {
+    readonly path: string;
+    readonly contents: string;
+    readonly productionPath: string;
+    constructor(path: string, contents: string, productionPath: string);
+}

package/dist/daml-interface/emission-model/generated-spec-file.js

@@ -0,0 +1,11 @@
+/** A runnable Node test generated beside one production DAML module. */
+export class GeneratedSpecFile {
+    path;
+    contents;
+    productionPath;
+    constructor(path, contents, productionPath) {
+        this.path = path;
+        this.contents = contents;
+        this.productionPath = productionPath;
+    }
+}

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

@@ -5,6 +5,7 @@ export { AnalyzedChoice } from "./analysis/analyzed-choice.js";
 export { AnalyzedTemplate, AnalyzedTemplateField } from "./analysis/analyzed-template.js";
 export { DamlInterfaceGenerator } from "./daml-interface-generator.js";
 export { DamlInterfaceGeneratorOptions } from "./daml-interface-generator-options.js";
+export { DamlModuleImportStyles } from "./emission/daml-module-import-style.js";
 export { GeneratedDamlInterfaceProject } from "./emission-model/generated-daml-interface-project.js";
 export { GeneratedTemplateBindingFile } from "./emission-model/generated-template-binding-file.js";
 export { GeneratedNamedTypeFile } from "./emission-model/generated-named-type-file.js";
@@ -14,12 +15,13 @@ export { DamlInterfaceWriteException } from "./errors/daml-interface-write.excep
 export { DamlInterfaceWriter } from "./writing/daml-interface-writer.js";
 export { DamlTemplate } from "./runtime/daml-template.js";
 export { DamlMaterializationError } from "./runtime/daml-materialization-error.js";
-export { decodeDamlValue } from "./runtime/daml-value-converter.js";
-export { materializeDamlValue } from "./runtime/daml-value-materializer.js";
-export { normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource, } from "./runtime/daml-event-source-normalizer.js";
+export { DamlValueConverter } from "./runtime/daml-value-converter.js";
+export { DamlValueMaterializer } from "./runtime/daml-value-materializer.js";
+export { DamlEventSourceNormalizer } from "./runtime/daml-event-source-normalizer.js";
 export { DamlNumeric } from "../core/types/daml-numeric.js";
 export { DamlParty } from "../core/types/daml-party.js";
 export { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant, } from "../core/types/daml-values.js";
+export type { DamlModuleImportStyle, } from "./emission/daml-module-import-style.js";
 export type { DamlDecodedValue, } from "./runtime/daml-value-converter.js";
 export type { DamlCreatedEventMetadata, DamlCreatedEventSource, DamlExercisedEventMetadata, DamlExercisedEventSource, DamlJsonEventRecord, DamlNormalizedCreatedEvent, DamlNormalizedExercisedEvent, } from "./runtime/daml-event-source-normalizer.js";
 export type { DamlContractIdDescriptor, DamlEnumDescriptor, DamlGenMapDescriptor, DamlListDescriptor, DamlNamedReferenceDescriptor, DamlOptionalDescriptor, DamlPrimitiveDescriptor, DamlPrimitiveType, DamlRecordDescriptor, DamlRecordFieldDescriptor, DamlTextMapDescriptor, DamlTypeDescriptor, DamlTypeDescriptorRegistry, DamlTypeIdentity, DamlValueSource, DamlVariantConstructorDescriptor, DamlVariantDescriptor, } from "./runtime/daml-type-descriptor.js";

package/dist/daml-interface/index.js

@@ -5,6 +5,7 @@ export { AnalyzedChoice } from "./analysis/analyzed-choice.js";
 export { AnalyzedTemplate, AnalyzedTemplateField } from "./analysis/analyzed-template.js";
 export { DamlInterfaceGenerator } from "./daml-interface-generator.js";
 export { DamlInterfaceGeneratorOptions } from "./daml-interface-generator-options.js";
+export { DamlModuleImportStyles } from "./emission/daml-module-import-style.js";
 export { GeneratedDamlInterfaceProject } from "./emission-model/generated-daml-interface-project.js";
 export { GeneratedTemplateBindingFile } from "./emission-model/generated-template-binding-file.js";
 export { GeneratedNamedTypeFile } from "./emission-model/generated-named-type-file.js";
@@ -14,9 +15,9 @@ export { DamlInterfaceWriteException } from "./errors/daml-interface-write.excep
 export { DamlInterfaceWriter } from "./writing/daml-interface-writer.js";
 export { DamlTemplate } from "./runtime/daml-template.js";
 export { DamlMaterializationError } from "./runtime/daml-materialization-error.js";
-export { decodeDamlValue } from "./runtime/daml-value-converter.js";
-export { materializeDamlValue } from "./runtime/daml-value-materializer.js";
-export { normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource, } from "./runtime/daml-event-source-normalizer.js";
+export { DamlValueConverter } from "./runtime/daml-value-converter.js";
+export { DamlValueMaterializer } from "./runtime/daml-value-materializer.js";
+export { DamlEventSourceNormalizer } from "./runtime/daml-event-source-normalizer.js";
 export { DamlNumeric } from "../core/types/daml-numeric.js";
 export { DamlParty } from "../core/types/daml-party.js";
 export { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant, } from "../core/types/daml-values.js";

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

@@ -39,14 +39,11 @@ export type DamlNormalizedExercisedEvent = {
     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;
+/** Recognizes Ledger API and PQS event sources as immutable DAML event shapes. */
+export declare class DamlEventSourceNormalizer {
+    private constructor();
+    /** Recognizes a Ledger API create event, contract response/wrapper, or PQS/JSON contract record. */
+    static normalizeCreated(source: DamlCreatedEventSource): DamlNormalizedCreatedEvent;
+    /** Recognizes a Ledger API exercise event or a PQS/JSON exercise record. */
+    static normalizeExercised(source: DamlExercisedEventSource): DamlNormalizedExercisedEvent;
+}

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

@@ -2,14 +2,23 @@ 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 { Value } from "../../transports/grpc/generated/canton/com/daml/ledger/api/v2/value.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) {
+/** Recognizes Ledger API and PQS event sources as immutable DAML event shapes. */
+export class DamlEventSourceNormalizer {
+    constructor() { }
+    /** Recognizes a Ledger API create event, contract response/wrapper, or PQS/JSON contract record. */
+    static normalizeCreated(source) {
+        return normalizeDamlCreatedEventSource(source);
+    }
+    /** Recognizes a Ledger API exercise event or a PQS/JSON exercise record. */
+    static normalizeExercised(source) {
+        return normalizeDamlExercisedEventSource(source);
+    }
+}
+function normalizeDamlCreatedEventSource(source) {
     const recognized = findNestedEvent(source, "created");
     const { event } = recognized;
     const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "created event source");
@@ -19,16 +28,11 @@ export function normalizeDamlCreatedEventSource(source) {
     return Object.freeze({
         kind: "created",
         contractId,
-        payload: freezeValueSource(payload, recognized.encoding === "protobuf" ? "protobuf-record" : "json"),
+        payload: freezeCreatedValueSource(payload, recognized.encoding),
         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) {
+function normalizeDamlExercisedEventSource(source) {
     const recognized = findNestedEvent(source, "exercised");
     const { event } = recognized;
     const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "exercised event source");
@@ -219,6 +223,166 @@ function freezeValueSource(value, encoding) {
     }
     return Object.freeze({ kind: "json", value: cloneAndFreeze(value) });
 }
+function freezeCreatedValueSource(value, encoding) {
+    if (encoding === "protobuf") {
+        return freezeValueSource(value, "protobuf-record");
+    }
+    else if (isRecordWireJson(value)) {
+        return freezeValueSource(Value.fromJson({ record: value }), "protobuf");
+    }
+    return freezeValueSource(value, "json");
+}
+const VALUE_JSON_VARIANTS = new Set([
+    "unit",
+    "bool",
+    "int64",
+    "date",
+    "timestamp",
+    "numeric",
+    "party",
+    "text",
+    "contractId",
+    "optional",
+    "list",
+    "textMap",
+    "genMap",
+    "record",
+    "variant",
+    "enum",
+]);
+function isRecordWireJson(value) {
+    const record = asObject(value);
+    return record !== undefined
+        && hasOnlyKeys(record, ["recordId", "fields"])
+        && Array.isArray(record.fields)
+        && isAbsentOr(record, "recordId", isIdentifierJson)
+        && record.fields.every(isRecordFieldJson);
+}
+function isRecordFieldJson(value) {
+    const field = asObject(value);
+    return field !== undefined
+        && hasOnlyKeys(field, ["label", "value"])
+        && isAbsentOr(field, "label", (label) => typeof label === "string")
+        && isValueJson(field.value);
+}
+function isValueJson(value) {
+    const json = asObject(value);
+    if (json === undefined) {
+        return false;
+    }
+    const variants = Object.keys(json).filter((key) => VALUE_JSON_VARIANTS.has(key));
+    if (variants.length !== 1 || Object.keys(json).length !== 1) {
+        return false;
+    }
+    const variant = variants[0];
+    switch (variant) {
+        case "unit":
+            return isEmptyJsonObject(json.unit);
+        case "bool":
+            return typeof json.bool === "boolean";
+        case "int64":
+        case "timestamp":
+        case "numeric":
+        case "party":
+        case "text":
+        case "contractId":
+            return typeof json[variant] === "string";
+        case "date":
+            return typeof json.date === "number" && Number.isSafeInteger(json.date);
+        case "optional":
+            return isOptionalJson(json.optional);
+        case "list":
+            return isListJson(json.list);
+        case "textMap":
+            return isTextMapJson(json.textMap);
+        case "genMap":
+            return isGenMapJson(json.genMap);
+        case "record":
+            return isNestedRecordJson(json.record);
+        case "variant":
+            return isVariantJson(json.variant);
+        case "enum":
+            return isEnumJson(json.enum);
+        default:
+            return false;
+    }
+}
+function isEmptyJsonObject(value) {
+    const json = asObject(value);
+    return json !== undefined && Object.keys(json).length === 0;
+}
+function isOptionalJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["value"])
+        && isAbsentOr(json, "value", isValueJson);
+}
+function isListJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["elements"])
+        && isAbsentOr(json, "elements", (elements) => Array.isArray(elements) && elements.every(isValueJson));
+}
+function isTextMapJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["entries"])
+        && isAbsentOr(json, "entries", (entries) => Array.isArray(entries) && entries.every((entry) => {
+            const item = asObject(entry);
+            return item !== undefined
+                && hasOnlyKeys(item, ["key", "value"])
+                && typeof item.key === "string"
+                && isValueJson(item.value);
+        }));
+}
+function isGenMapJson(value) {
+    const json = asObject(value);
+    return json !== undefined
+        && hasOnlyKeys(json, ["entries"])
+        && isAbsentOr(json, "entries", (entries) => Array.isArray(entries) && entries.every((entry) => {
+            const item = asObject(entry);
+            return item !== undefined
+                && hasOnlyKeys(item, ["key", "value"])
+                && isValueJson(item.key)
+                && isValueJson(item.value);
+        }));
+}
+function isNestedRecordJson(value) {
+    const record = asObject(value);
+    return record !== undefined
+        && hasOnlyKeys(record, ["recordId", "fields"])
+        && isAbsentOr(record, "recordId", isIdentifierJson)
+        && isAbsentOr(record, "fields", (fields) => Array.isArray(fields) && fields.every(isRecordFieldJson));
+}
+function isVariantJson(value) {
+    const variant = asObject(value);
+    return variant !== undefined
+        && hasOnlyKeys(variant, ["variantId", "constructor", "value"])
+        && isAbsentOr(variant, "variantId", isIdentifierJson)
+        && typeof variant.constructor === "string"
+        && isValueJson(variant.value);
+}
+function isEnumJson(value) {
+    const enumValue = asObject(value);
+    return enumValue !== undefined
+        && hasOnlyKeys(enumValue, ["enumId", "constructor"])
+        && isAbsentOr(enumValue, "enumId", isIdentifierJson)
+        && typeof enumValue.constructor === "string";
+}
+function isIdentifierJson(value) {
+    const identifier = asObject(value);
+    return identifier !== undefined
+        && hasOnlyKeys(identifier, ["packageId", "moduleName", "entityName"])
+        && typeof identifier.packageId === "string"
+        && typeof identifier.moduleName === "string"
+        && typeof identifier.entityName === "string";
+}
+function hasOnlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+function isAbsentOr(value, key, predicate) {
+    return !Object.prototype.hasOwnProperty.call(value, key) || predicate(value[key]);
+}
 function optionalString(event, names, label, path) {
     const property = readProperty(event, names);
     if (!property.found) {

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

@@ -55,12 +55,13 @@ export type DamlEnumDescriptor = {
 export type DamlNamedReferenceDescriptor = {
     readonly kind: "namedReference";
     readonly identity: DamlTypeIdentity;
+    readonly typeArguments: readonly DamlTypeDescriptor[];
 };
 /** 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;
+    readonly resolve: (identity: DamlTypeIdentity, typeArguments: readonly DamlTypeDescriptor[]) => DamlTypeDescriptor | undefined;
 };
 export type DamlValueSource = {
     readonly kind: "protobuf";

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

@@ -3,5 +3,8 @@ 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;
+/** Decodes protobuf or JSON/PQS DAML values according to generated descriptors. */
+export declare class DamlValueConverter {
+    private constructor();
+    static decode(source: DamlValueSource, descriptor: DamlTypeDescriptor, registry: DamlTypeDescriptorRegistry, path: string): DamlDecodedValue;
+}

package/dist/daml-interface/runtime/daml-value-converter.js

@@ -8,14 +8,20 @@ const DAML_MIN_TIMESTAMP_MICROSECONDS = -62135596800000000n;
 const DAML_MAX_TIMESTAMP_MICROSECONDS = 253402300799999999n;
 const DAML_MIN_INT64 = -9223372036854775808n;
 const DAML_MAX_INT64 = 9223372036854775807n;
-/** Decodes a protobuf or JSON/PQS DAML value according to its generated descriptor. */
-export function decodeDamlValue(source, descriptor, registry, path) {
+/** Decodes protobuf or JSON/PQS DAML values according to generated descriptors. */
+export class DamlValueConverter {
+    constructor() { }
+    static decode(source, descriptor, registry, path) {
+        return decodeDamlValue(source, descriptor, registry, path);
+    }
+}
+function decodeDamlValue(source, descriptor, registry, path) {
     if (descriptor.kind === "namedReference") {
-        const factory = registry.resolve(descriptor.identity);
-        if (factory === undefined) {
+        const resolved = registry.resolve(descriptor.identity, descriptor.typeArguments);
+        if (resolved === undefined) {
             throw materializationError(path, "named type descriptor is not registered");
         }
-        return decodeDamlValue(source, factory(), registry, path);
+        return decodeDamlValue(source, resolved, registry, path);
     }
     else if (source.kind === "protobuf") {
         return decodeProtobufValue(source.value, descriptor, registry, path);

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

@@ -1,3 +1,6 @@
 import { DamlDecodedValue } from "./daml-value-converter.js";
 /** Converts decoded DAML containers into the shapes exposed by generated TypeScript declarations. */
-export declare function materializeDamlValue<T>(value: DamlDecodedValue): T;
+export declare class DamlValueMaterializer {
+    private constructor();
+    static materialize<T>(value: DamlDecodedValue): T;
+}

package/dist/daml-interface/runtime/daml-value-materializer.js

@@ -1,6 +1,12 @@
 import { DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlVariant, } from "../../core/types/daml-values.js";
 /** Converts decoded DAML containers into the shapes exposed by generated TypeScript declarations. */
-export function materializeDamlValue(value) {
+export class DamlValueMaterializer {
+    constructor() { }
+    static materialize(value) {
+        return materializeDamlValue(value);
+    }
+}
+function materializeDamlValue(value) {
     return materialize(value);
 }
 function materialize(value) {

package/dist/daml-interface/writing/daml-interface-writer.js

@@ -4,12 +4,9 @@ export class DamlInterfaceWriter {
     /** Writes a generated in-memory project to the requested output directory. */
     async writeProjectAsync(project, outputDirectory) {
         const files = [
-            ...project.templateFiles,
-            ...project.namedTypeFiles,
-            ...project.supportFiles,
-            project.registryFile,
-            project.indexFile,
-        ].filter((item) => item !== undefined);
+            ...project.productionFiles,
+            ...project.specFiles,
+        ];
         for (const file of files) {
             const path = join(outputDirectory, file.path);
             await mkdir(dirname(path), {

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

@@ -1,5 +1,6 @@
 import { DamlLfChoice } from "./model/daml-lf-choice.js";
 import { DamlLfModule } from "./model/daml-lf-module.js";
+import { DamlLfPackage } from "./model/daml-lf-package.js";
 import { DamlLfTemplate } from "./model/daml-lf-template.js";
 import { DamlLfTemplateId } from "./model/daml-lf-template-id.js";
 import { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
@@ -30,6 +31,8 @@ export declare class DamlLfCompilation {
         definitionName: string;
     };
     getTemplates(): readonly DamlLfTemplate[];
+    /** Returns the packages available to this compilation. */
+    getPackages(): readonly DamlLfPackage[];
     getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
     private buildIndexes;
     private validateReferencesOrThrow;

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

@@ -70,6 +70,10 @@ export class DamlLfCompilation {
     getTemplates() {
         return [...this.templates.values()];
     }
+    /** Returns the packages available to this compilation. */
+    getPackages() {
+        return this.workspace.packages;
+    }
     getTemplateChoicesOrThrow(templateId) {
         return this.getTemplateOrThrow(templateId).choices;
     }

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

@@ -2,6 +2,23 @@ import { DamlLfDefinition } from "./daml-lf-definition.js";
 import { DamlLfField } from "./daml-lf-field.js";
 import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 import { DamlLfType } from "./daml-lf-type.js";
+export type DamlLfTypeParameterKind = {
+    readonly kind: "star";
+} | {
+    readonly kind: "nat";
+} | {
+    readonly kind: "arrow";
+    readonly parameters: readonly DamlLfTypeParameterKind[];
+    readonly result: DamlLfTypeParameterKind;
+} | {
+    readonly kind: "unknown";
+    readonly internedKindIndex?: number;
+};
+export interface DamlLfTypeParameter {
+    readonly name?: string;
+    readonly internedStringIndex: number;
+    readonly kind: DamlLfTypeParameterKind;
+}
 export type DamlLfDataTypeDefinition = {
     readonly kind: "record";
     readonly fields: readonly DamlLfField[];
@@ -20,9 +37,11 @@ export declare class DamlLfDataType extends DamlLfDefinition {
     readonly nodeKind = DamlLfNodeKind.dataType;
     readonly definition: DamlLfDataTypeDefinition;
     readonly fields: readonly DamlLfField[];
+    readonly typeParameters: readonly DamlLfTypeParameter[];
     constructor(init: {
         name: string;
         definition?: DamlLfDataTypeDefinition;
         fields?: readonly DamlLfField[];
+        typeParameters?: readonly DamlLfTypeParameter[];
     });
 }

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

@@ -4,6 +4,7 @@ export class DamlLfDataType extends DamlLfDefinition {
     nodeKind = DamlLfNodeKind.dataType;
     definition;
     fields;
+    typeParameters;
     constructor(init) {
         super({
             name: init.name,
@@ -15,5 +16,19 @@ export class DamlLfDataType extends DamlLfDefinition {
         this.fields = this.definition.kind === "record"
             ? this.definition.fields
             : [];
+        this.typeParameters = Object.freeze((init.typeParameters ?? []).map((parameter) => Object.freeze({
+            ...parameter,
+            kind: freezeTypeParameterKind(parameter.kind),
+        })));
     }
 }
+function freezeTypeParameterKind(kind) {
+    if (kind.kind !== "arrow") {
+        return Object.freeze({ ...kind });
+    }
+    return Object.freeze({
+        kind: "arrow",
+        parameters: Object.freeze(kind.parameters.map((parameter) => freezeTypeParameterKind(parameter))),
+        result: freezeTypeParameterKind(kind.result),
+    });
+}

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

@@ -1,16 +1,29 @@
 import { DamlLfBuiltinType } from "./daml-lf-builtin-type.js";
+import { DamlLfTypeParameter } from "./daml-lf-data-type.js";
 import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 import { TypeConReference } from "./type-con-reference.js";
+export interface DamlLfTypeVariableReference {
+    readonly name?: string;
+    readonly internedStringIndex: number;
+}
+export interface DamlLfDiagnosticForall {
+    readonly typeParameters: readonly DamlLfTypeParameter[];
+    readonly body: DamlLfType;
+}
 export declare class DamlLfType {
     readonly nodeKind = DamlLfNodeKind.type;
     readonly builtinType: DamlLfBuiltinType;
     readonly numericScale?: number;
     readonly typeConReference?: TypeConReference;
+    readonly typeVariable?: DamlLfTypeVariableReference;
+    readonly diagnosticForall?: DamlLfDiagnosticForall;
     readonly typeArguments: readonly DamlLfType[];
     constructor(init: {
         builtinType?: DamlLfBuiltinType;
         numericScale?: number;
         typeConReference?: TypeConReference;
+        typeVariable?: DamlLfTypeVariableReference;
+        diagnosticForall?: DamlLfDiagnosticForall;
         typeArguments?: readonly DamlLfType[];
     });
 }

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

@@ -5,6 +5,8 @@ export class DamlLfType {
     builtinType;
     numericScale;
     typeConReference;
+    typeVariable;
+    diagnosticForall;
     typeArguments;
     constructor(init) {
         this.builtinType = init.builtinType ?? DamlLfBuiltinType.unknown;
@@ -12,6 +14,28 @@ export class DamlLfType {
             this.numericScale = init.numericScale;
         }
         this.typeConReference = init.typeConReference;
+        this.typeVariable = init.typeVariable === undefined
+            ? undefined
+            : Object.freeze({ ...init.typeVariable });
+        this.diagnosticForall = init.diagnosticForall === undefined
+            ? undefined
+            : Object.freeze({
+                typeParameters: Object.freeze(init.diagnosticForall.typeParameters.map((parameter) => Object.freeze({
+                    ...parameter,
+                    kind: freezeTypeParameterKind(parameter.kind),
+                }))),
+                body: init.diagnosticForall.body,
+            });
         this.typeArguments = Object.freeze([...(init.typeArguments ?? [])]);
     }
 }
+function freezeTypeParameterKind(kind) {
+    if (kind.kind !== "arrow") {
+        return Object.freeze({ ...kind });
+    }
+    return Object.freeze({
+        kind: "arrow",
+        parameters: Object.freeze(kind.parameters.map((parameter) => freezeTypeParameterKind(parameter))),
+        result: freezeTypeParameterKind(kind.result),
+    });
+}

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

@@ -4,6 +4,9 @@ import { DamlLfPackage } from "./daml-lf-package.js";
 export declare class Lf2ModelMapper {
     static mapPackage(packageId: string, rawPackage: LfArchivePackage, languageVersion: DamlLfLanguageVersion): DamlLfPackage;
     private static mapType;
+    private static mapTypeParameter;
+    private static mapTypeVariableReference;
+    private static mapTypeParameterKind;
     private static mapBuiltinType;
     private static readNumericScale;
     private static mapModule;
@@ -21,5 +24,6 @@ export declare class Lf2ModelMapper {
     private static mapUpdateExpression;
     private static mapTemplateReferenceOrThrow;
     private static resolveInternedString;
+    private static resolveInternedStringOrUndefined;
     private static resolveInternedDottedName;
 }