@distrohelena/canton-typescript-sdk 0.1.4 → 0.1.6

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

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

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

@@ -1,10 +1,12 @@
 import { DamlLfBuiltinDispatch } from "./daml-lf-builtin-dispatch.js";
+import { DamlLfEvaluator } from "./daml-lf-evaluator.js";
 export class DamlLfInterpreterScaffold {
     compilation;
     builtinDispatch = new DamlLfBuiltinDispatch();
+    evaluator;
     constructor(compilation) {
         this.compilation = compilation;
-        void this.compilation;
+        this.evaluator = new DamlLfEvaluator(this.compilation, this.builtinDispatch);
     }
     getCompilation() {
         return this.compilation;
@@ -12,4 +14,7 @@ export class DamlLfInterpreterScaffold {
     getBuiltinDispatch() {
         return this.builtinDispatch;
     }
+    getEvaluator() {
+        return this.evaluator;
+    }
 }

package/dist/daml-lf/interpreter/daml-lf-lexical-scope.d.ts

@@ -0,0 +1,13 @@
+import { IDamlLfRuntimeValue } from "./daml-lf-runtime-value.js";
+export declare class DamlLfLexicalScope {
+    private readonly parent?;
+    private readonly bindings;
+    constructor(parent?: DamlLfLexicalScope | undefined);
+    getBinding(name: string): IDamlLfRuntimeValue | undefined;
+    setBinding(name: string, value: IDamlLfRuntimeValue): void;
+    createChild(): DamlLfLexicalScope;
+    snapshotBindings(): readonly {
+        name: string;
+        value: IDamlLfRuntimeValue;
+    }[];
+}

package/dist/daml-lf/interpreter/daml-lf-lexical-scope.js

@@ -0,0 +1,46 @@
+export class DamlLfLexicalScope {
+    parent;
+    bindings = new Map();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    getBinding(name) {
+        const visited = new Set();
+        let current = this;
+        while (current !== undefined && !visited.has(current)) {
+            visited.add(current);
+            const binding = current.bindings.get(name);
+            if (binding !== undefined) {
+                return binding;
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+    setBinding(name, value) {
+        this.bindings.set(name, value);
+    }
+    createChild() {
+        return new DamlLfLexicalScope(this);
+    }
+    snapshotBindings() {
+        const scopes = [];
+        const resolved = new Map();
+        const visited = new Set();
+        let current = this;
+        while (current !== undefined && !visited.has(current)) {
+            visited.add(current);
+            scopes.push(current);
+            current = current.parent;
+        }
+        for (let index = scopes.length - 1; index >= 0; index -= 1) {
+            for (const [name, value] of scopes[index].bindings.entries()) {
+                resolved.set(name, value);
+            }
+        }
+        return [...resolved.entries()].map(([name, value]) => ({
+            name,
+            value,
+        }));
+    }
+}

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

@@ -0,0 +1,16 @@
+import { DamlLfValueDefinition } from "../model/daml-lf-value-definition.js";
+import { DamlLfLexicalScope } from "./daml-lf-lexical-scope.js";
+export declare class DamlLfRuntimeFrame {
+    readonly frameId: string;
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly definition: DamlLfValueDefinition;
+    readonly scope: DamlLfLexicalScope;
+    constructor(init: {
+        frameId: string;
+        packageId: string;
+        moduleName: string;
+        definition: DamlLfValueDefinition;
+        scope?: DamlLfLexicalScope;
+    });
+}

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

@@ -0,0 +1,15 @@
+import { DamlLfLexicalScope } from "./daml-lf-lexical-scope.js";
+export class DamlLfRuntimeFrame {
+    frameId;
+    packageId;
+    moduleName;
+    definition;
+    scope;
+    constructor(init) {
+        this.frameId = init.frameId;
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.definition = init.definition;
+        this.scope = init.scope ?? new DamlLfLexicalScope();
+    }
+}

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

@@ -1,3 +1,24 @@
 export interface IDamlLfRuntimeValue {
     readonly kind: string;
+    readonly [key: string]: unknown;
+}
+export declare const DAML_LF_CONTRACT_ID_MARKER_KEY = "__damlLfContractId";
+export declare const DAML_LF_NUMERIC_MARKER_KEY = "__damlLfNumeric";
+export declare const DAML_LF_PARTY_MARKER_KEY = "__damlLfParty";
+export declare const DAML_LF_RECORD_ID_MARKER_KEY = "__damlLfRecordId";
+export interface IDamlLfContractIdMarkerValue {
+    readonly [DAML_LF_CONTRACT_ID_MARKER_KEY]: string;
+}
+export interface IDamlLfPartyMarkerValue {
+    readonly [DAML_LF_PARTY_MARKER_KEY]: string;
+}
+export interface IDamlLfNumericMarkerValue {
+    readonly [DAML_LF_NUMERIC_MARKER_KEY]: string;
+}
+export interface IDamlLfRecordIdMarkerValue {
+    readonly [DAML_LF_RECORD_ID_MARKER_KEY]: {
+        readonly packageId?: string;
+        readonly moduleName?: string;
+        readonly entityName?: string;
+    };
 }

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

@@ -1 +1,4 @@
-export {};
+export const DAML_LF_CONTRACT_ID_MARKER_KEY = "__damlLfContractId";
+export const DAML_LF_NUMERIC_MARKER_KEY = "__damlLfNumeric";
+export const DAML_LF_PARTY_MARKER_KEY = "__damlLfParty";
+export const DAML_LF_RECORD_ID_MARKER_KEY = "__damlLfRecordId";

package/dist/daml-lf/interpreter/daml-lf-step-kind.d.ts

@@ -0,0 +1,7 @@
+export declare enum DamlLfStepKind {
+    stateEffect = "stateEffect",
+    call = "call",
+    return = "return",
+    enterExpression = "enterExpression",
+    exitExpression = "exitExpression"
+}

package/dist/daml-lf/interpreter/daml-lf-step-kind.js

@@ -0,0 +1,8 @@
+export var DamlLfStepKind;
+(function (DamlLfStepKind) {
+    DamlLfStepKind["stateEffect"] = "stateEffect";
+    DamlLfStepKind["call"] = "call";
+    DamlLfStepKind["return"] = "return";
+    DamlLfStepKind["enterExpression"] = "enterExpression";
+    DamlLfStepKind["exitExpression"] = "exitExpression";
+})(DamlLfStepKind || (DamlLfStepKind = {}));

package/dist/daml-lf/interpreter/daml-lf-trace-sink.interface.d.ts

@@ -0,0 +1,30 @@
+import { DamlLfExpression } from "../model/daml-lf-expression.js";
+import { IDamlLfRuntimeValue } from "./daml-lf-runtime-value.js";
+import { DamlLfRuntimeFrame } from "./daml-lf-runtime-frame.js";
+import { DamlLfStepKind } from "./daml-lf-step-kind.js";
+export interface IDamlLfReplayEffect {
+    readonly kind: "create" | "exercise" | "archive" | "fetch" | "lookup";
+    readonly contractId?: string;
+    readonly templateId?: {
+        readonly packageId?: string;
+        readonly moduleName?: string;
+        readonly entityName?: string;
+    };
+    readonly choice?: string;
+    readonly argument?: unknown;
+    readonly payload?: unknown;
+}
+export interface IDamlLfTraceStep {
+    readonly kind: DamlLfStepKind;
+    readonly expression: DamlLfExpression;
+    readonly frame: DamlLfRuntimeFrame;
+    readonly locals: readonly {
+        readonly name: string;
+        readonly value: IDamlLfRuntimeValue;
+    }[];
+    readonly value?: IDamlLfRuntimeValue;
+    readonly stateEffect?: IDamlLfReplayEffect;
+}
+export interface IDamlLfTraceSink {
+    onStep(step: IDamlLfTraceStep): void;
+}

package/dist/daml-lf/interpreter/daml-lf-trace-sink.interface.js

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

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

@@ -1,4 +1,7 @@
 export declare enum DamlLfBuiltinType {
+    int64 = "int64",
+    numeric = "numeric",
+    party = "party",
     text = "text",
     unknown = "unknown"
 }

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

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

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

@@ -1,16 +1,21 @@
 import { DamlLfChoiceParameter } from "./daml-lf-choice-parameter.js";
+import { DamlLfExpression } from "./daml-lf-expression.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 selfBinderName: string;
     readonly parameter: DamlLfChoiceParameter;
     readonly returnType: DamlLfType;
+    readonly updateExpression?: DamlLfExpression;
     constructor(init: {
         name: string;
+        selfBinderName: string;
         parameter: DamlLfChoiceParameter;
         consuming?: boolean;
         returnType?: DamlLfType;
+        updateExpression?: DamlLfExpression;
     });
 }

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

@@ -3,12 +3,16 @@ export class DamlLfChoice {
     nodeKind = DamlLfNodeKind.choice;
     name;
     consuming;
+    selfBinderName;
     parameter;
     returnType;
+    updateExpression;
     constructor(init) {
         this.name = init.name;
         this.parameter = init.parameter;
         this.consuming = init.consuming ?? true;
+        this.selfBinderName = init.selfBinderName;
         this.returnType = init.returnType ?? init.parameter.type;
+        this.updateExpression = init.updateExpression;
     }
 }

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

@@ -0,0 +1,2 @@
+import { DamlLfExpression } from "./daml-lf-expression.js";
+export declare function getDamlLfExpressionAtPath(root: DamlLfExpression, path: readonly number[]): DamlLfExpression | undefined;

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

@@ -0,0 +1,81 @@
+// This child ordering is the compiler/SDK sidecar wire contract.
+export function getDamlLfExpressionAtPath(root, path) {
+    let expression = root;
+    for (const childIndex of path) {
+        if (!Number.isSafeInteger(childIndex) || childIndex < 0) {
+            return undefined;
+        }
+        expression = getDamlLfExpressionChildren(expression)[childIndex];
+        if (expression === undefined) {
+            return undefined;
+        }
+    }
+    return expression;
+}
+function getDamlLfExpressionChildren(expression) {
+    if (expression.lambda !== undefined) {
+        return [expression.lambda.body];
+    }
+    if (expression.application !== undefined) {
+        return [
+            expression.application.function,
+            ...expression.application.arguments,
+        ];
+    }
+    if (expression.letExpression !== undefined) {
+        return [
+            ...expression.letExpression.bindings.map((binding) => binding.value),
+            expression.letExpression.body,
+        ];
+    }
+    if (expression.recordConstruction !== undefined) {
+        return expression.recordConstruction.fields.map((field) => field.value);
+    }
+    if (expression.recordProjection !== undefined) {
+        return [expression.recordProjection.record];
+    }
+    if (expression.recordUpdate !== undefined) {
+        return [
+            expression.recordUpdate.record,
+            expression.recordUpdate.value,
+        ];
+    }
+    if (expression.caseExpression !== undefined) {
+        return [
+            expression.caseExpression.scrutinee,
+            ...expression.caseExpression.alternatives.map((alternative) => alternative.body),
+        ];
+    }
+    if (expression.variantConstruction !== undefined) {
+        return [expression.variantConstruction.argument];
+    }
+    if (expression.optionalConstruction?.value !== undefined) {
+        return [expression.optionalConstruction.value];
+    }
+    if (expression.listConstruction !== undefined) {
+        return [
+            ...expression.listConstruction.front,
+            ...(expression.listConstruction.tail === undefined
+                ? []
+                : [expression.listConstruction.tail]),
+        ];
+    }
+    if (expression.updateExpression !== undefined) {
+        return [
+            ...(expression.updateExpression.expression === undefined
+                ? []
+                : [expression.updateExpression.expression]),
+            ...(expression.updateExpression.bindings?.map((binding) => binding.value) ?? []),
+            ...(expression.updateExpression.body === undefined
+                ? []
+                : [expression.updateExpression.body]),
+            ...(expression.updateExpression.contractId === undefined
+                ? []
+                : [expression.updateExpression.contractId]),
+            ...(expression.updateExpression.argument === undefined
+                ? []
+                : [expression.updateExpression.argument]),
+        ];
+    }
+    return [];
+}

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

@@ -1,8 +1,154 @@
 import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
+export interface IDamlLfValueReference {
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly definitionName: string;
+}
+export interface IDamlLfExpressionSourceLocation {
+    readonly packageId?: string;
+    readonly moduleName?: string;
+    readonly startLine: number;
+    readonly startColumn: number;
+    readonly endLine: number;
+    readonly endColumn: number;
+}
+export interface IDamlLfLambdaExpression {
+    readonly parameters: readonly string[];
+    readonly body: DamlLfExpression;
+}
+export interface IDamlLfApplicationExpression {
+    readonly function: DamlLfExpression;
+    readonly arguments: readonly DamlLfExpression[];
+}
+export interface IDamlLfLetBinding {
+    readonly name: string;
+    readonly value: DamlLfExpression;
+}
+export interface IDamlLfLetExpression {
+    readonly bindings: readonly IDamlLfLetBinding[];
+    readonly body: DamlLfExpression;
+}
+export interface IDamlLfRecordFieldExpression {
+    readonly name: string;
+    readonly value: DamlLfExpression;
+}
+export interface IDamlLfRecordConstructionExpression {
+    readonly fields: readonly IDamlLfRecordFieldExpression[];
+}
+export interface IDamlLfRecordProjectionExpression {
+    readonly fieldName: string;
+    readonly record: DamlLfExpression;
+}
+export interface IDamlLfRecordUpdateExpression {
+    readonly fieldName: string;
+    readonly record: DamlLfExpression;
+    readonly value: DamlLfExpression;
+}
+export interface IDamlLfThrowExpression {
+    readonly exception: DamlLfExpression;
+}
+export type DamlLfBuiltinConstructor = "unit" | "false" | "true";
+export type DamlLfBuiltinFunction = "equal" | "greater" | "appendText" | string;
+export interface IDamlLfVariantConstructionExpression {
+    readonly constructorName: string;
+    readonly argument: DamlLfExpression;
+}
+export interface IDamlLfOptionalConstructionExpression {
+    readonly value?: DamlLfExpression;
+}
+export interface IDamlLfEnumConstructionExpression {
+    readonly constructorName: string;
+}
+export interface IDamlLfListConstructionExpression {
+    readonly front: readonly DamlLfExpression[];
+    readonly tail?: DamlLfExpression;
+}
+export interface IDamlLfUpdateBinding {
+    readonly name: string;
+    readonly value: DamlLfExpression;
+}
+export interface IDamlLfUpdateExpression {
+    readonly kind: "pure" | "block" | "embedExpr" | "tryCatch" | "create" | "createInterface" | "fetch" | "fetchInterface" | "exercise" | "exerciseInterface" | "getTime" | "ledgerTimeLt";
+    readonly expression?: DamlLfExpression;
+    readonly bindings?: readonly IDamlLfUpdateBinding[];
+    readonly body?: DamlLfExpression;
+    readonly catchVariableName?: string;
+    readonly catchExpression?: DamlLfExpression;
+    readonly templateId?: {
+        readonly packageId: string;
+        readonly moduleName: string;
+        readonly templateName: string;
+    };
+    readonly interfaceId?: {
+        readonly packageId: string;
+        readonly moduleName: string;
+        readonly templateName: string;
+    };
+    readonly choiceName?: string;
+    readonly contractId?: DamlLfExpression;
+    readonly argument?: DamlLfExpression;
+    readonly guardExpression?: DamlLfExpression;
+}
+export interface IDamlLfCaseAlternative {
+    readonly patternKind: "default" | "builtinCon" | "variant" | "optionalNone" | "optionalSome" | "enum" | "nil" | "cons";
+    readonly builtinConstructor?: DamlLfBuiltinConstructor;
+    readonly constructorName?: string;
+    readonly binderName?: string;
+    readonly headBinderName?: string;
+    readonly tailBinderName?: string;
+    readonly body: DamlLfExpression;
+}
+export interface IDamlLfCaseExpression {
+    readonly scrutinee: DamlLfExpression;
+    readonly alternatives: readonly IDamlLfCaseAlternative[];
+}
 export declare class DamlLfExpression {
     readonly nodeKind = DamlLfNodeKind.expression;
     readonly textLiteral?: string;
+    readonly numericLiteral?: string;
+    readonly int64Literal?: string;
+    readonly valueReference?: IDamlLfValueReference;
+    readonly variableName?: string;
+    readonly lambda?: IDamlLfLambdaExpression;
+    readonly application?: IDamlLfApplicationExpression;
+    readonly letExpression?: IDamlLfLetExpression;
+    readonly recordConstruction?: IDamlLfRecordConstructionExpression;
+    readonly recordProjection?: IDamlLfRecordProjectionExpression;
+    readonly recordUpdate?: IDamlLfRecordUpdateExpression;
+    readonly throwExpression?: IDamlLfThrowExpression;
+    readonly builtinConstructor?: DamlLfBuiltinConstructor;
+    readonly builtinFunction?: DamlLfBuiltinFunction;
+    readonly caseExpression?: IDamlLfCaseExpression;
+    readonly variantConstruction?: IDamlLfVariantConstructionExpression;
+    readonly optionalConstruction?: IDamlLfOptionalConstructionExpression;
+    readonly enumConstruction?: IDamlLfEnumConstructionExpression;
+    readonly listConstruction?: IDamlLfListConstructionExpression;
+    readonly updateExpression?: IDamlLfUpdateExpression;
+    readonly unsupportedNodeKind?: string;
+    readonly sourceLocation?: IDamlLfExpressionSourceLocation;
     constructor(init: {
         textLiteral?: string;
+        numericLiteral?: string;
+        int64Literal?: string;
+        valueReference?: IDamlLfValueReference;
+        variableName?: string;
+        lambda?: IDamlLfLambdaExpression;
+        application?: IDamlLfApplicationExpression;
+        letExpression?: IDamlLfLetExpression;
+        recordConstruction?: IDamlLfRecordConstructionExpression;
+        recordProjection?: IDamlLfRecordProjectionExpression;
+        recordUpdate?: IDamlLfRecordUpdateExpression;
+        throwExpression?: IDamlLfThrowExpression;
+        builtinConstructor?: DamlLfBuiltinConstructor;
+        builtinFunction?: DamlLfBuiltinFunction;
+        caseExpression?: IDamlLfCaseExpression;
+        variantConstruction?: IDamlLfVariantConstructionExpression;
+        optionalConstruction?: IDamlLfOptionalConstructionExpression;
+        enumConstruction?: IDamlLfEnumConstructionExpression;
+        listConstruction?: IDamlLfListConstructionExpression;
+        updateExpression?: IDamlLfUpdateExpression;
+        unsupportedNodeKind?: string;
+        sourceLocation?: IDamlLfExpressionSourceLocation;
     });
+    withSourceLocation(sourceLocation: IDamlLfExpressionSourceLocation | undefined): DamlLfExpression;
 }

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

@@ -2,7 +2,78 @@ import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 export class DamlLfExpression {
     nodeKind = DamlLfNodeKind.expression;
     textLiteral;
+    numericLiteral;
+    int64Literal;
+    valueReference;
+    variableName;
+    lambda;
+    application;
+    letExpression;
+    recordConstruction;
+    recordProjection;
+    recordUpdate;
+    throwExpression;
+    builtinConstructor;
+    builtinFunction;
+    caseExpression;
+    variantConstruction;
+    optionalConstruction;
+    enumConstruction;
+    listConstruction;
+    updateExpression;
+    unsupportedNodeKind;
+    sourceLocation;
     constructor(init) {
         this.textLiteral = init.textLiteral;
+        this.numericLiteral = init.numericLiteral;
+        this.int64Literal = init.int64Literal;
+        this.valueReference = init.valueReference;
+        this.variableName = init.variableName;
+        this.lambda = init.lambda;
+        this.application = init.application;
+        this.letExpression = init.letExpression;
+        this.recordConstruction = init.recordConstruction;
+        this.recordProjection = init.recordProjection;
+        this.recordUpdate = init.recordUpdate;
+        this.throwExpression = init.throwExpression;
+        this.builtinConstructor = init.builtinConstructor;
+        this.builtinFunction = init.builtinFunction;
+        this.caseExpression = init.caseExpression;
+        this.variantConstruction = init.variantConstruction;
+        this.optionalConstruction = init.optionalConstruction;
+        this.enumConstruction = init.enumConstruction;
+        this.listConstruction = init.listConstruction;
+        this.updateExpression = init.updateExpression;
+        this.unsupportedNodeKind = init.unsupportedNodeKind;
+        this.sourceLocation = init.sourceLocation;
+    }
+    withSourceLocation(sourceLocation) {
+        if (sourceLocation === undefined) {
+            return this;
+        }
+        return new DamlLfExpression({
+            textLiteral: this.textLiteral,
+            numericLiteral: this.numericLiteral,
+            int64Literal: this.int64Literal,
+            valueReference: this.valueReference,
+            variableName: this.variableName,
+            lambda: this.lambda,
+            application: this.application,
+            letExpression: this.letExpression,
+            recordConstruction: this.recordConstruction,
+            recordProjection: this.recordProjection,
+            recordUpdate: this.recordUpdate,
+            throwExpression: this.throwExpression,
+            builtinConstructor: this.builtinConstructor,
+            builtinFunction: this.builtinFunction,
+            caseExpression: this.caseExpression,
+            variantConstruction: this.variantConstruction,
+            optionalConstruction: this.optionalConstruction,
+            enumConstruction: this.enumConstruction,
+            listConstruction: this.listConstruction,
+            updateExpression: this.updateExpression,
+            unsupportedNodeKind: this.unsupportedNodeKind,
+            sourceLocation,
+        });
     }
 }

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

@@ -6,11 +6,13 @@ import { DamlLfTemplateId } from "./daml-lf-template-id.js";
 export declare class DamlLfTemplate extends DamlLfDefinition {
     readonly nodeKind = DamlLfNodeKind.template;
     readonly templateId: DamlLfTemplateId;
+    readonly parameterName: string;
     readonly fields: readonly DamlLfField[];
     readonly choices: readonly DamlLfChoice[];
     constructor(init: {
         templateId: DamlLfTemplateId;
         name: string;
+        parameterName: string;
         fields: readonly DamlLfField[];
         choices: readonly DamlLfChoice[];
     });

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

@@ -3,6 +3,7 @@ import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 export class DamlLfTemplate extends DamlLfDefinition {
     nodeKind = DamlLfNodeKind.template;
     templateId;
+    parameterName;
     fields;
     choices;
     constructor(init) {
@@ -10,6 +11,7 @@ export class DamlLfTemplate extends DamlLfDefinition {
             name: init.name,
         });
         this.templateId = init.templateId;
+        this.parameterName = init.parameterName;
         this.fields = init.fields;
         this.choices = init.choices;
     }

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

@@ -4,9 +4,11 @@ import { TypeConReference } from "./type-con-reference.js";
 export declare class DamlLfType {
     readonly nodeKind = DamlLfNodeKind.type;
     readonly builtinType: DamlLfBuiltinType;
+    readonly numericScale?: number;
     readonly typeConReference?: TypeConReference;
     constructor(init: {
         builtinType?: DamlLfBuiltinType;
+        numericScale?: number;
         typeConReference?: TypeConReference;
     });
 }

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

@@ -3,9 +3,13 @@ import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 export class DamlLfType {
     nodeKind = DamlLfNodeKind.type;
     builtinType;
+    numericScale;
     typeConReference;
     constructor(init) {
         this.builtinType = init.builtinType ?? DamlLfBuiltinType.unknown;
+        if (init.numericScale !== undefined) {
+            this.numericScale = init.numericScale;
+        }
         this.typeConReference = init.typeConReference;
     }
 }

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 readNumericScale;
     private static mapModule;
     private static mapDataType;
     private static mapTemplateOrThrow;
@@ -14,6 +15,10 @@ export declare class Lf2ModelMapper {
     private static resolvePackageIdOrThrow;
     private static resolveImportedPackageIdOrThrow;
     private static mapExpression;
+    private static mapExpressionWithoutSourceLocation;
+    private static mapExpressionSourceLocation;
+    private static mapUpdateExpression;
+    private static mapTemplateReferenceOrThrow;
     private static resolveInternedString;
     private static resolveInternedDottedName;
 }