@distrohelena/canton-typescript-sdk 0.1.22 → 0.1.25

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

@@ -0,0 +1,370 @@
+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 { DamlMaterializationError } from "./daml-materialization-error.js";
+const DAML_MIN_DATE_DAYS_SINCE_EPOCH = -719162;
+const DAML_MAX_DATE_DAYS_SINCE_EPOCH = 2932896;
+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) {
+    if (descriptor.kind === "namedReference") {
+        const factory = registry.resolve(descriptor.identity);
+        if (factory === undefined) {
+            throw materializationError(path, "named type descriptor is not registered");
+        }
+        return decodeDamlValue(source, factory(), registry, path);
+    }
+    else if (source.kind === "protobuf") {
+        return decodeProtobufValue(source.value, descriptor, registry, path);
+    }
+    return decodeJsonValue(source.value, descriptor, registry, path);
+}
+function decodeProtobufValue(value, descriptor, registry, path) {
+    switch (value.sum.oneofKind) {
+        case undefined:
+            throw materializationError(path, "value is absent");
+        case "unit":
+            requirePrimitiveDescriptor(descriptor, "unit", path);
+            return new DamlUnit();
+        case "bool":
+            requirePrimitiveDescriptor(descriptor, "bool", path);
+            return value.sum.bool;
+        case "int64":
+            requirePrimitiveDescriptor(descriptor, "int64", path);
+            return decodeInt64(value.sum.int64, path);
+        case "date":
+            requirePrimitiveDescriptor(descriptor, "date", path);
+            return decodeDate(value.sum.date, path);
+        case "timestamp":
+            requirePrimitiveDescriptor(descriptor, "timestamp", path);
+            return decodeTimestamp(value.sum.timestamp, path);
+        case "numeric":
+            requirePrimitiveDescriptor(descriptor, "numeric", path);
+            return decodeNumeric(value.sum.numeric, descriptor.numericScale, path);
+        case "party":
+            requirePrimitiveDescriptor(descriptor, "party", path);
+            return decodeParty(value.sum.party, path);
+        case "text":
+            requirePrimitiveDescriptor(descriptor, "text", path);
+            return value.sum.text;
+        case "contractId":
+            requireDescriptorKind(descriptor, "contractId", path, "contractId");
+            return value.sum.contractId;
+        case "optional":
+            requireDescriptorKind(descriptor, "optional", path, "optional");
+            return value.sum.optional.value === undefined
+                ? undefined
+                : decodeDamlValue({ kind: "protobuf", value: value.sum.optional.value }, descriptor.element, registry, path);
+        case "list":
+            requireDescriptorKind(descriptor, "list", path, "list");
+            return value.sum.list.elements.map((element, index) => decodeDamlValue({ kind: "protobuf", value: element }, descriptor.element, registry, indexedPath(path, index)));
+        case "textMap":
+            requireDescriptorKind(descriptor, "textMap", path, "textMap");
+            return new DamlTextMap(value.sum.textMap.entries.map((entry, index) => [
+                entry.key,
+                decodeRequiredProtobufValue(entry.value, descriptor.value, registry, `${indexedPath(path, index)}.${entry.key}`),
+            ]));
+        case "genMap":
+            requireDescriptorKind(descriptor, "genMap", path, "genMap");
+            return new DamlGenMap(value.sum.genMap.entries.map((entry, index) => [
+                decodeRequiredProtobufValue(entry.key, descriptor.key, registry, `${indexedPath(path, index)}.key`),
+                decodeRequiredProtobufValue(entry.value, descriptor.value, registry, `${indexedPath(path, index)}.value`),
+            ]));
+        case "record":
+            requireDescriptorKind(descriptor, "record", path, "record");
+            return decodeProtobufRecord(value.sum.record, descriptor, registry, path);
+        case "variant": {
+            requireDescriptorKind(descriptor, "variant", path, "variant");
+            const variant = value.sum.variant;
+            const constructor = descriptor.constructors.find((candidate) => candidate.constructor === variant.constructor);
+            if (constructor === undefined) {
+                throw materializationError(path, `unknown variant constructor ${variant.constructor}`);
+            }
+            return new DamlVariant(variant.constructor, decodeRequiredProtobufValue(variant.value, constructor.payload, registry, `${path}.${variant.constructor}`));
+        }
+        case "enum":
+            requireDescriptorKind(descriptor, "enum", path, "enum");
+            if (!descriptor.constructors.includes(value.sum.enum.constructor)) {
+                throw materializationError(path, `unknown enum constructor ${value.sum.enum.constructor}`);
+            }
+            return new DamlEnum(value.sum.enum.constructor);
+        default:
+            return rejectUnknownProtobufKind(path, value.sum);
+    }
+}
+function decodeProtobufRecord(record, descriptor, registry, path) {
+    const fields = record.fields;
+    const labelsPresent = fields.every((field) => field.label.length > 0);
+    const labelsAbsent = fields.every((field) => field.label.length === 0);
+    if (!labelsPresent && !labelsAbsent) {
+        throw materializationError(path, "record fields mix labelled and positional encodings");
+    }
+    const output = Object.create(null);
+    if (labelsPresent) {
+        if (new Set(fields.map((field) => field.label)).size !== fields.length) {
+            throw materializationError(path, "record contains duplicate field labels");
+        }
+        for (const field of descriptor.fields) {
+            const sourceField = fields.find((candidate) => candidate.label === field.damlLabel);
+            if (sourceField === undefined) {
+                throw materializationError(fieldPath(path, field.propertyName), "required record field is absent");
+            }
+            output[field.propertyName] = decodeRequiredProtobufValue(sourceField.value, field.type, registry, fieldPath(path, field.propertyName));
+        }
+        if (fields.length !== descriptor.fields.length) {
+            throw materializationError(path, "record contains an unexpected field");
+        }
+    }
+    else {
+        if (fields.length !== descriptor.fields.length) {
+            throw materializationError(path, "record has the wrong number of positional fields");
+        }
+        descriptor.fields.forEach((field, index) => {
+            output[field.propertyName] = decodeRequiredProtobufValue(fields[index]?.value, field.type, registry, fieldPath(path, field.propertyName));
+        });
+    }
+    return new DamlRecord(output);
+}
+function decodeJsonValue(value, descriptor, registry, path) {
+    switch (descriptor.kind) {
+        case "primitive":
+            return decodeJsonPrimitive(value, descriptor, path);
+        case "contractId":
+            return requireString(value, path, "contract ID");
+        case "optional":
+            return value === null ? undefined : decodeDamlValue({ kind: "json", value }, descriptor.element, registry, path);
+        case "list":
+            return requireArray(value, path, "list").map((element, index) => decodeDamlValue({ kind: "json", value: element }, descriptor.element, registry, indexedPath(path, index)));
+        case "textMap":
+            return decodeJsonTextMap(value, descriptor, registry, path);
+        case "genMap":
+            return new DamlGenMap(requireArray(value, path, "generic map").map((entry, index) => {
+                const pair = requireArray(entry, indexedPath(path, index), "generic map entry");
+                if (pair.length !== 2) {
+                    throw materializationError(indexedPath(path, index), "generic map entries must contain key and value");
+                }
+                return [
+                    decodeDamlValue({ kind: "json", value: pair[0] }, descriptor.key, registry, `${indexedPath(path, index)}.key`),
+                    decodeDamlValue({ kind: "json", value: pair[1] }, descriptor.value, registry, `${indexedPath(path, index)}.value`),
+                ];
+            }));
+        case "record":
+            return decodeJsonRecord(value, descriptor, registry, path);
+        case "variant":
+            return decodeJsonVariant(value, descriptor, registry, path);
+        case "enum": {
+            const constructor = requireString(value, path, "enum constructor");
+            if (!descriptor.constructors.includes(constructor)) {
+                throw materializationError(path, `unknown enum constructor ${constructor}`);
+            }
+            return new DamlEnum(constructor);
+        }
+    }
+}
+function decodeJsonPrimitive(value, descriptor, path) {
+    switch (descriptor.primitive) {
+        case "unit": {
+            const record = requireObject(value, path, "unit");
+            if (Object.keys(record).length !== 0) {
+                throw materializationError(path, "unit must be an empty object");
+            }
+            return new DamlUnit();
+        }
+        case "bool":
+            if (typeof value !== "boolean") {
+                throw materializationError(path, "expected boolean");
+            }
+            return value;
+        case "int64":
+            return decodeInt64(requireString(value, path, "int64"), path);
+        case "date":
+            return decodeDate(value, path);
+        case "timestamp":
+            return decodeTimestamp(value, path);
+        case "numeric":
+            return decodeNumeric(requireString(value, path, "numeric"), descriptor.numericScale, path);
+        case "party":
+            return decodeParty(requireString(value, path, "party"), path);
+        case "text":
+            return requireString(value, path, "text");
+    }
+}
+function decodeJsonTextMap(value, descriptor, registry, path) {
+    const record = requireObject(value, path, "text map");
+    return new DamlTextMap(objectEntries(record).map(([key, entryValue]) => [
+        key,
+        decodeDamlValue({ kind: "json", value: entryValue }, descriptor.value, registry, fieldPath(path, key)),
+    ]));
+}
+function decodeJsonRecord(value, descriptor, registry, path) {
+    const output = Object.create(null);
+    if (Array.isArray(value)) {
+        if (value.length !== descriptor.fields.length) {
+            throw materializationError(path, "record has the wrong number of positional fields");
+        }
+        descriptor.fields.forEach((field, index) => {
+            output[field.propertyName] = decodeDamlValue({ kind: "json", value: value[index] }, field.type, registry, fieldPath(path, field.propertyName));
+        });
+        return new DamlRecord(output);
+    }
+    const record = requireObject(value, path, "record");
+    const expectedLabels = new Set(descriptor.fields.map((field) => field.damlLabel));
+    for (const [label] of objectEntries(record)) {
+        if (!expectedLabels.has(label)) {
+            throw materializationError(path, `record contains unexpected field ${label}`);
+        }
+    }
+    for (const field of descriptor.fields) {
+        if (!Object.hasOwn(record, field.damlLabel)) {
+            throw materializationError(fieldPath(path, field.propertyName), "required record field is absent");
+        }
+        output[field.propertyName] = decodeDamlValue({ kind: "json", value: Reflect.get(record, field.damlLabel) }, field.type, registry, fieldPath(path, field.propertyName));
+    }
+    return new DamlRecord(output);
+}
+function decodeJsonVariant(value, descriptor, registry, path) {
+    const envelope = requireObject(value, path, "variant");
+    const tag = requireString(Reflect.get(envelope, "tag"), path, "variant tag");
+    const constructor = descriptor.constructors.find((candidate) => candidate.constructor === tag);
+    if (constructor === undefined) {
+        throw materializationError(path, `unknown variant constructor ${tag}`);
+    }
+    else if (!Object.hasOwn(envelope, "value")) {
+        throw materializationError(path, "variant value is absent");
+    }
+    return new DamlVariant(tag, decodeDamlValue({ kind: "json", value: Reflect.get(envelope, "value") }, constructor.payload, registry, `${path}.${tag}`));
+}
+function decodeRequiredProtobufValue(value, descriptor, registry, path) {
+    if (value === undefined) {
+        throw materializationError(path, "required value is absent");
+    }
+    return decodeDamlValue({ kind: "protobuf", value }, descriptor, registry, path);
+}
+function requirePrimitiveDescriptor(descriptor, primitive, path) {
+    if (descriptor.kind !== "primitive" || descriptor.primitive !== primitive) {
+        throw materializationError(path, `expected ${descriptor.kind} but received ${primitive}`);
+    }
+}
+function requireDescriptorKind(descriptor, expected, path, received) {
+    if (descriptor.kind !== expected) {
+        throw materializationError(path, `expected ${descriptor.kind} but received ${received}`);
+    }
+}
+function rejectUnknownProtobufKind(path, _value) {
+    throw materializationError(path, "value has an unknown protobuf oneof kind");
+}
+function requireArray(value, path, description) {
+    if (!Array.isArray(value)) {
+        throw materializationError(path, `expected ${description} array`);
+    }
+    return value;
+}
+function requireObject(value, path, description) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw materializationError(path, `expected ${description} object`);
+    }
+    return value;
+}
+function requireString(value, path, description) {
+    if (typeof value !== "string") {
+        throw materializationError(path, `expected ${description} string`);
+    }
+    return value;
+}
+function requireIntegerString(value, path, description) {
+    const result = requireString(value, path, description);
+    if (!/^-?(?:0|[1-9]\d*)$/.test(result)) {
+        throw materializationError(path, `expected ${description} integer string`);
+    }
+    return result;
+}
+function decodeInt64(value, path) {
+    const integer = requireIntegerString(value, path, "int64");
+    let int64;
+    try {
+        int64 = BigInt(integer);
+    }
+    catch {
+        throw materializationError(path, "invalid int64");
+    }
+    if (int64 < DAML_MIN_INT64 || int64 > DAML_MAX_INT64) {
+        throw materializationError(path, "int64 is outside the DAML ledger range");
+    }
+    return int64;
+}
+function decodeDate(value, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw materializationError(path, "expected integer date");
+    }
+    else if (value < DAML_MIN_DATE_DAYS_SINCE_EPOCH || value > DAML_MAX_DATE_DAYS_SINCE_EPOCH) {
+        throw materializationError(path, "date is outside the DAML ledger range");
+    }
+    return new DamlDate(value);
+}
+function decodeTimestamp(value, path) {
+    const microseconds = requireIntegerString(value, path, "timestamp");
+    const timestamp = BigInt(microseconds);
+    if (timestamp < DAML_MIN_TIMESTAMP_MICROSECONDS || timestamp > DAML_MAX_TIMESTAMP_MICROSECONDS) {
+        throw materializationError(path, "timestamp is outside the DAML ledger range");
+    }
+    return new DamlTimestamp(microseconds);
+}
+function decodeNumeric(value, numericScale, path) {
+    if (!/^[+-]?\d+(?:\.\d*)?$/.test(value)) {
+        throw materializationError(path, "invalid numeric");
+    }
+    const decimalSeparator = value.indexOf(".");
+    const fractionLength = decimalSeparator === -1 ? 0 : value.length - decimalSeparator - 1;
+    const precision = value.replace(/[+-.]/g, "").length;
+    const maxScale = numericScale ?? 37;
+    if (!Number.isInteger(maxScale) || maxScale < 0 || maxScale > 37) {
+        throw materializationError(path, "numeric descriptor has an invalid scale");
+    }
+    else if (precision > 38) {
+        throw materializationError(path, "numeric exceeds DAML ledger precision");
+    }
+    else if (fractionLength > maxScale) {
+        throw materializationError(path, "numeric exceeds its DAML scale");
+    }
+    try {
+        return new DamlNumeric(canonicalizeLedgerNumeric(value));
+    }
+    catch {
+        throw materializationError(path, "invalid numeric");
+    }
+}
+function canonicalizeLedgerNumeric(value) {
+    const negative = value.startsWith("-");
+    const unsigned = value.startsWith("+") || negative ? value.slice(1) : value;
+    const decimalSeparator = unsigned.indexOf(".");
+    const integerPart = decimalSeparator === -1 ? unsigned : unsigned.slice(0, decimalSeparator);
+    const fractionPart = decimalSeparator === -1 ? "" : unsigned.slice(decimalSeparator + 1);
+    const canonicalIntegerPart = integerPart.replace(/^0+/, "") || "0";
+    const sign = negative ? "-" : "";
+    return fractionPart.length === 0
+        ? `${sign}${canonicalIntegerPart}`
+        : `${sign}${canonicalIntegerPart}.${fractionPart}`;
+}
+function decodeParty(value, path) {
+    try {
+        return new DamlParty(value);
+    }
+    catch {
+        throw materializationError(path, "invalid party");
+    }
+}
+function objectEntries(record) {
+    return Object.keys(record).map((key) => [key, Reflect.get(record, key)]);
+}
+function fieldPath(path, propertyName) {
+    return `${path}.${propertyName}`;
+}
+function indexedPath(path, index) {
+    return `${path}[${index}]`;
+}
+function materializationError(path, detail) {
+    return new DamlMaterializationError(path, detail);
+}

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

@@ -0,0 +1,3 @@
+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;

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

@@ -0,0 +1,23 @@
+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) {
+    return materialize(value);
+}
+function materialize(value) {
+    if (value instanceof DamlRecord) {
+        return Object.fromEntries(Object.entries(value.fields).map(([name, field]) => [name, materialize(field)]));
+    }
+    else if (value instanceof DamlVariant) {
+        return Object.freeze({ tag: value.constructorName, value: materialize(value.value) });
+    }
+    else if (value instanceof DamlEnum) {
+        return value.constructorName;
+    }
+    else if (value instanceof DamlTextMap || value instanceof DamlGenMap) {
+        return new Map(value.entries.map(([key, entry]) => [materialize(key), materialize(entry)]));
+    }
+    else if (Array.isArray(value)) {
+        return value.map((element) => materialize(element));
+    }
+    return value;
+}

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

@@ -5,6 +5,7 @@ export class DamlInterfaceWriter {
     async writeProjectAsync(project, outputDirectory) {
         const files = [
             ...project.templateFiles,
+            ...project.namedTypeFiles,
             ...project.supportFiles,
             project.registryFile,
             project.indexFile,

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

@@ -33,6 +33,7 @@ export declare class DamlLfCompilation {
     private buildIndexes;
     private validateReferencesOrThrow;
     private validateTypeOrThrow;
+    private validateDataTypeOrThrow;
     private static createModuleKey;
     private static createTypeKey;
     private static createDefinitionKey;

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

@@ -105,9 +105,7 @@ export class DamlLfCompilation {
                         this.validateTypeOrThrow(definition.type);
                     }
                     if (definition instanceof DamlLfDataType) {
-                        for (const field of definition.fields) {
-                            this.validateTypeOrThrow(field.type);
-                        }
+                        this.validateDataTypeOrThrow(definition);
                     }
                     if (definition instanceof DamlLfTemplate) {
                         this.getTypeSymbolOrThrow(definition.templateId.toTypeConReference());
@@ -124,12 +122,28 @@ export class DamlLfCompilation {
         }
     }
     validateTypeOrThrow(type) {
+        for (const typeArgument of type.typeArguments) {
+            this.validateTypeOrThrow(typeArgument);
+        }
         const reference = type.typeConReference;
         if (reference === undefined) {
             return;
         }
         this.getTypeSymbolOrThrow(reference);
     }
+    validateDataTypeOrThrow(definition) {
+        if (definition.definition.kind === "record") {
+            for (const field of definition.definition.fields) {
+                this.validateTypeOrThrow(field.type);
+            }
+            return;
+        }
+        else if (definition.definition.kind === "variant") {
+            for (const constructor of definition.definition.constructors) {
+                this.validateTypeOrThrow(constructor.type);
+            }
+        }
+    }
     static createModuleKey(packageId, moduleName) {
         return `${packageId}::${moduleName}`;
     }

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

@@ -1,7 +1,16 @@
 export declare enum DamlLfBuiltinType {
+    unit = "unit",
+    bool = "bool",
     int64 = "int64",
+    date = "date",
+    timestamp = "timestamp",
     numeric = "numeric",
     party = "party",
     text = "text",
+    contractId = "contractId",
+    optional = "optional",
+    list = "list",
+    textMap = "textMap",
+    genMap = "genMap",
     unknown = "unknown"
 }

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

@@ -1,8 +1,17 @@
 export var DamlLfBuiltinType;
 (function (DamlLfBuiltinType) {
+    DamlLfBuiltinType["unit"] = "unit";
+    DamlLfBuiltinType["bool"] = "bool";
     DamlLfBuiltinType["int64"] = "int64";
+    DamlLfBuiltinType["date"] = "date";
+    DamlLfBuiltinType["timestamp"] = "timestamp";
     DamlLfBuiltinType["numeric"] = "numeric";
     DamlLfBuiltinType["party"] = "party";
     DamlLfBuiltinType["text"] = "text";
+    DamlLfBuiltinType["contractId"] = "contractId";
+    DamlLfBuiltinType["optional"] = "optional";
+    DamlLfBuiltinType["list"] = "list";
+    DamlLfBuiltinType["textMap"] = "textMap";
+    DamlLfBuiltinType["genMap"] = "genMap";
     DamlLfBuiltinType["unknown"] = "unknown";
 })(DamlLfBuiltinType || (DamlLfBuiltinType = {}));

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

@@ -1,11 +1,28 @@
 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 DamlLfDataTypeDefinition = {
+    readonly kind: "record";
+    readonly fields: readonly DamlLfField[];
+} | {
+    readonly kind: "variant";
+    readonly constructors: readonly DamlLfVariantConstructor[];
+} | {
+    readonly kind: "enum";
+    readonly constructors: readonly string[];
+};
+export interface DamlLfVariantConstructor {
+    readonly name: string;
+    readonly type: DamlLfType;
+}
 export declare class DamlLfDataType extends DamlLfDefinition {
     readonly nodeKind = DamlLfNodeKind.dataType;
+    readonly definition: DamlLfDataTypeDefinition;
     readonly fields: readonly DamlLfField[];
     constructor(init: {
         name: string;
-        fields: readonly DamlLfField[];
+        definition?: DamlLfDataTypeDefinition;
+        fields?: readonly DamlLfField[];
     });
 }

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

@@ -2,11 +2,18 @@ import { DamlLfDefinition } from "./daml-lf-definition.js";
 import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 export class DamlLfDataType extends DamlLfDefinition {
     nodeKind = DamlLfNodeKind.dataType;
+    definition;
     fields;
     constructor(init) {
         super({
             name: init.name,
         });
-        this.fields = init.fields;
+        this.definition = init.definition ?? {
+            kind: "record",
+            fields: init.fields ?? [],
+        };
+        this.fields = this.definition.kind === "record"
+            ? this.definition.fields
+            : [];
     }
 }

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

@@ -6,9 +6,11 @@ export declare class DamlLfType {
     readonly builtinType: DamlLfBuiltinType;
     readonly numericScale?: number;
     readonly typeConReference?: TypeConReference;
+    readonly typeArguments: readonly DamlLfType[];
     constructor(init: {
         builtinType?: DamlLfBuiltinType;
         numericScale?: number;
         typeConReference?: TypeConReference;
+        typeArguments?: readonly DamlLfType[];
     });
 }

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

@@ -5,11 +5,13 @@ export class DamlLfType {
     builtinType;
     numericScale;
     typeConReference;
+    typeArguments;
     constructor(init) {
         this.builtinType = init.builtinType ?? DamlLfBuiltinType.unknown;
         if (init.numericScale !== undefined) {
             this.numericScale = init.numericScale;
         }
         this.typeConReference = init.typeConReference;
+        this.typeArguments = Object.freeze([...(init.typeArguments ?? [])]);
     }
 }

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

@@ -4,6 +4,7 @@ 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 mapBuiltinType;
     private static readNumericScale;
     private static mapModule;
     private static mapDataType;