@distrohelena/canton-typescript-sdk 0.1.22 → 0.1.25

package/dist/daml-interface/emission/type-script-name-resolver.js

@@ -1,43 +1,401 @@
 import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
+const typeScriptKeywords = new Set([
+    "as", "async", "await", "break", "case", "catch", "class", "const", "continue",
+    "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false",
+    "finally", "for", "from", "function", "get", "if", "implements", "import", "in",
+    "instanceof", "interface", "let", "new", "null", "of", "package", "private", "protected",
+    "public", "return", "set", "static", "super", "switch", "this", "throw", "true", "try",
+    "type", "typeof", "undefined", "var", "void", "while", "with", "yield",
+]);
+const damlTemplateMemberNames = new Set([
+    "constructor", "get", "contractId", "templateId", "create", "decodeCreatedEvent",
+    "decodeExercisedEvent",
+]);
+const reservedTypeNames = new Set(["DamlTemplate"]);
+const reservedNamespaceAliases = new Set(["GeneratedRegistry"]);
 export class TypeScriptNameResolver {
+    templatesByIdentity = new Map();
+    resolvedTemplates = new Map();
+    resolvedModules = new Map();
+    constructor(templates = []) {
+        this.prepareTemplatesOrThrow(templates);
+    }
+    /** Prepares a project-wide name table and rejects irreconcilable output collisions. */
+    prepareTemplatesOrThrow(templates) {
+        this.prepareProjectOrThrow(templates, []);
+    }
+    /** Prepares shared package/module paths for template and named DAML type output. */
+    prepareProjectOrThrow(templates, typeDefinitions) {
+        this.templatesByIdentity.clear();
+        this.resolvedTemplates.clear();
+        this.resolvedModules.clear();
+        for (const template of templates) {
+            const identityKey = this.getTemplateIdentityKey(template);
+            const existing = this.templatesByIdentity.get(identityKey);
+            if (existing !== undefined) {
+                throw new Error(`Cannot generate duplicate DAML template identity '${this.describeTemplate(template)}' `
+                    + `and '${this.describeTemplate(existing)}'`);
+            }
+            this.templatesByIdentity.set(identityKey, template);
+        }
+        const allTemplates = [...this.templatesByIdentity.values()];
+        const modulesByIdentity = new Map();
+        for (const template of allTemplates) {
+            modulesByIdentity.set(this.getPackageModuleIdentityKey(template), {
+                packageId: template.templateId.packageId,
+                moduleName: template.templateId.moduleName,
+            });
+        }
+        for (const definition of typeDefinitions) {
+            modulesByIdentity.set(this.getPackageModuleIdentityKeyFromParts(definition.identity.packageId, definition.identity.moduleName), {
+                packageId: definition.identity.packageId,
+                moduleName: definition.identity.moduleName,
+            });
+        }
+        const packageIds = [...new Set([...modulesByIdentity.values()].map((module) => module.packageId))];
+        const packageDirectories = this.resolveNames(packageIds.map((packageId) => ({
+            value: packageId,
+            key: `package\u0000${packageId}`,
+            baseName: this.toKebabCase(packageId),
+            scope: "packages",
+        })));
+        const moduleDirectories = this.resolveNames([...modulesByIdentity.entries()].map(([identityKey, module]) => ({
+            value: identityKey,
+            key: `module\u0000${identityKey}`,
+            baseName: this.getModuleDirectory(module.moduleName),
+            scope: module.packageId,
+        })));
+        const fileNames = this.resolveNames(allTemplates.map((template) => ({
+            value: template,
+            key: this.getTemplateIdentityKey(template),
+            baseName: this.getTemplateFileBaseName(template),
+            scope: `${template.templateId.packageId}\u0000${template.templateId.moduleName}`,
+        })));
+        const namespaceAliases = this.resolveNames([...modulesByIdentity.entries()].map(([identityKey, module]) => ({
+            value: identityKey,
+            key: `namespace\u0000${identityKey}`,
+            baseName: this.safeNamespaceAlias(`${module.packageId} ${module.moduleName}`),
+            collisionSeparator: "_",
+        })));
+        const classNames = this.resolveNames(allTemplates.map((template) => ({
+            value: template,
+            key: this.getTemplateIdentityKey(template),
+            baseName: this.safeTypeName(template.templateId.templateName),
+            collisionSeparator: "_",
+        })));
+        this.resolvedModules = new Map([...modulesByIdentity.entries()].map(([identityKey, module]) => {
+            const packageDirectory = packageDirectories.get(module.packageId);
+            const moduleDirectory = moduleDirectories.get(identityKey);
+            const namespaceAlias = namespaceAliases.get(identityKey);
+            if (packageDirectory === undefined || moduleDirectory === undefined || namespaceAlias === undefined) {
+                throw new Error(`Could not resolve generated path for '${module.packageId}:${module.moduleName}'`);
+            }
+            return [
+                identityKey,
+                {
+                    ...module,
+                    directoryPath: `generated/packages/${packageDirectory}/${moduleDirectory}`,
+                    namespaceAlias,
+                },
+            ];
+        }));
+        this.resolvedTemplates = new Map(allTemplates.map((template) => {
+            const identityKey = this.getTemplateIdentityKey(template);
+            const className = classNames.get(template);
+            if (className === undefined) {
+                throw new Error(`Could not resolve generated class name for '${this.describeTemplate(template)}'`);
+            }
+            const fileName = fileNames.get(template);
+            const module = this.resolvedModules.get(this.getPackageModuleIdentityKey(template));
+            if (fileName === undefined ||
+                module === undefined) {
+                throw new Error(`Could not resolve generated path for '${this.describeTemplate(template)}'`);
+            }
+            return [
+                identityKey,
+                {
+                    template,
+                    identityKey,
+                    namespaceAlias: module.namespaceAlias,
+                    filePath: `${module.directoryPath}/${fileName}.ts`,
+                    className,
+                    fieldNames: this.resolveFieldNames(template),
+                    choiceNames: this.resolveChoiceNames(template, className, identityKey),
+                },
+            ];
+        }));
+        this.assertDistinctTemplateOutput("file path", (resolved) => resolved.filePath);
+        this.assertDistinctNamespaceAliases(namespaceAliases);
+        this.assertDistinctTemplateOutput("class name", (resolved) => resolved.className);
+    }
+    /** Resolves the full package/module/entity identity key for a template. */
+    getTemplateIdentityKey(template) {
+        return [
+            template.templateId.packageId,
+            template.templateId.moduleName,
+            template.templateId.templateName,
+        ].join("\u0000");
+    }
+    /** Resolves the generated namespace alias for a template package/module. */
+    getNamespaceAlias(template) {
+        return this.getResolvedTemplate(template).namespaceAlias;
+    }
     /** Resolves the generated file path for a template binding. */
     getTemplateFilePath(template) {
-        return `generated/${this.getModuleDirectory(template)}/${template.fileName}`;
+        return this.getResolvedTemplate(template).filePath;
+    }
+    /** Resolves the generated class name for a template binding. */
+    getTemplateClassName(template) {
+        return this.getResolvedTemplate(template).className;
+    }
+    /** Resolves the output directory shared by a named DAML type package/module. */
+    getNamedTypeModuleDirectoryPath(packageId, moduleName) {
+        return this.getResolvedModule(packageId, moduleName).directoryPath;
+    }
+    /** Resolves the generated namespace alias shared by templates and named DAML types. */
+    getNamedTypeModuleNamespaceAlias(packageId, moduleName) {
+        return this.getResolvedModule(packageId, moduleName).namespaceAlias;
     }
     /** Resolves the generated create-fields type name for a template. */
     getCreateFieldsTypeName(template) {
-        return `${template.className}CreateFields`;
+        return `${this.getTemplateClassName(template)}Fields`;
     }
     /** Resolves the generated created-event type name for a template. */
     getCreatedEventTypeName(template) {
-        return `${template.className}CreatedEvent`;
+        return `${this.getTemplateClassName(template)}CreatedEvent`;
+    }
+    /** Resolves the generated property name for an original DAML template field. */
+    getFieldPropertyName(template, field) {
+        return this.getResolvedField(template, field).propertyName;
+    }
+    /** Resolves the generated constructor parameter for an original DAML template field. */
+    getFieldConstructorParameterName(template, field) {
+        return this.getResolvedField(template, field).constructorParameterName;
+    }
+    /** Resolves the generated exercise method name for a DAML choice. */
+    getChoiceMethodName(template, choice) {
+        return this.getResolvedChoice(template, choice).methodName;
     }
     /** Resolves the generated choice payload type name for a template choice. */
     getChoiceTypeName(template, choice) {
-        return `${template.className}${choice.name}Choice`;
+        return this.getResolvedChoice(template, choice).choiceTypeName;
     }
     /** Resolves the generated exercised-event type name for a template choice. */
     getExercisedEventTypeName(template, choice) {
-        return `${template.className}${choice.name}ExercisedEvent`;
+        return this.getResolvedChoice(template, choice).exercisedEventTypeName;
+    }
+    /** Resolves the generated parameter property name for a DAML choice. */
+    getChoiceParameterName(template, choice) {
+        return this.getResolvedChoice(template, choice).parameterName;
+    }
+    /** Resolves the full identity key for a DAML choice. */
+    getChoiceIdentityKey(template, choice) {
+        return this.getResolvedChoice(template, choice).identityKey;
     }
     /** Resolves the TypeScript type name for a supported DAML-LF type. */
     getTypeName(type) {
-        return type.builtinType === DamlLfBuiltinType.text ? "string" : "unknown";
+        return type.kind === "primitive" && type.builtinType === DamlLfBuiltinType.text
+            ? "string"
+            : "unknown";
     }
     /** Resolves the literal template identifier used by generated helpers. */
     getTemplateIdLiteral(template) {
-        return `${template.templateId.moduleName}:${template.templateId.templateName}`;
+        return `${template.templateId.packageId}:${template.templateId.moduleName}:${template.templateId.templateName}`;
+    }
+    getResolvedTemplate(template) {
+        const identityKey = this.getTemplateIdentityKey(template);
+        if (!this.resolvedTemplates.has(identityKey)) {
+            this.prepareTemplatesOrThrow([template]);
+        }
+        const resolved = this.resolvedTemplates.get(identityKey);
+        if (resolved === undefined) {
+            throw new Error(`Could not resolve DAML template '${this.describeTemplate(template)}'`);
+        }
+        return resolved;
+    }
+    getResolvedModule(packageId, moduleName) {
+        const module = this.resolvedModules.get(this.getPackageModuleIdentityKeyFromParts(packageId, moduleName));
+        if (module === undefined) {
+            throw new Error(`Could not resolve DAML module '${packageId}:${moduleName}'`);
+        }
+        return module;
+    }
+    getResolvedField(template, field) {
+        const resolved = this.getResolvedTemplate(template).fieldNames.get(field);
+        if (resolved === undefined) {
+            throw new Error(`Could not resolve field '${field.name}' for '${this.describeTemplate(template)}'`);
+        }
+        return resolved;
     }
-    getModuleDirectory(template) {
-        return template.templateId.moduleName
+    getResolvedChoice(template, choice) {
+        const resolved = this.getResolvedTemplate(template).choiceNames.get(choice);
+        if (resolved === undefined) {
+            throw new Error(`Could not resolve choice '${choice.name}' for '${this.describeTemplate(template)}'`);
+        }
+        return resolved;
+    }
+    resolveFieldNames(template) {
+        const propertyNames = this.resolveNames(template.createFields.map((field, index) => ({
+            value: field,
+            key: `${this.getTemplateIdentityKey(template)}\u0000field\u0000${field.name}\u0000${index}`,
+            baseName: this.safeMemberName(field.name),
+            collisionSeparator: "_",
+        })));
+        return new Map(template.createFields.map((field) => {
+            const propertyName = propertyNames.get(field);
+            if (propertyName === undefined) {
+                throw new Error(`Could not resolve field '${field.name}' for '${this.describeTemplate(template)}'`);
+            }
+            return [field, { propertyName, constructorParameterName: propertyName }];
+        }));
+    }
+    resolveChoiceNames(template, className, templateIdentityKey) {
+        const stems = this.resolveNames(template.choices.map((choice, index) => ({
+            value: choice,
+            key: `${templateIdentityKey}\u0000choice\u0000${choice.name}\u0000${index}`,
+            baseName: this.safeTypeName(choice.name),
+            collisionSeparator: "_",
+        })));
+        return new Map(template.choices.map((choice) => {
+            const stem = stems.get(choice);
+            if (stem === undefined) {
+                throw new Error(`Could not resolve choice '${choice.name}' for '${this.describeTemplate(template)}'`);
+            }
+            const choiceIdentityKey = `${templateIdentityKey}\u0000${choice.name}`;
+            return [
+                choice,
+                {
+                    methodName: this.safeMemberName(`exercise${stem}`),
+                    choiceTypeName: `${className}${stem}Choice`,
+                    exercisedEventTypeName: `${className}${stem}ExercisedEvent`,
+                    parameterName: this.safeMemberName(choice.parameterName),
+                    identityKey: choiceIdentityKey,
+                },
+            ];
+        }));
+    }
+    resolveNames(values) {
+        const groups = new Map();
+        for (const value of values) {
+            const groupKey = `${value.scope ?? ""}\u0000${value.baseName}`;
+            groups.set(groupKey, (groups.get(groupKey) ?? 0) + 1);
+        }
+        const names = new Map();
+        const allocatedNamesByScope = new Map();
+        for (const value of [...values].sort((left, right) => left.key.localeCompare(right.key))) {
+            const scope = value.scope ?? "";
+            const groupKey = `${scope}\u0000${value.baseName}`;
+            const groupSize = groups.get(groupKey);
+            if (groupSize === undefined) {
+                throw new Error(`Could not resolve generated name '${value.baseName}'`);
+            }
+            const collisionSuffix = `${value.collisionSeparator ?? "-"}${this.shortHash(value.key)}`;
+            const baseCandidate = groupSize === 1
+                ? value.baseName
+                : `${value.baseName}${collisionSuffix}`;
+            const allocatedNames = allocatedNamesByScope.get(scope) ?? new Set();
+            let candidate = baseCandidate;
+            let escalation = 2;
+            while (allocatedNames.has(candidate)) {
+                candidate = `${baseCandidate}_${escalation}`;
+                escalation += 1;
+            }
+            allocatedNames.add(candidate);
+            allocatedNamesByScope.set(scope, allocatedNames);
+            names.set(value.value, candidate);
+        }
+        return names;
+    }
+    assertDistinctTemplateOutput(outputName, getOutput) {
+        const outputs = new Map();
+        for (const resolved of this.resolvedTemplates.values()) {
+            const output = getOutput(resolved);
+            const existing = outputs.get(output);
+            if (existing !== undefined && existing.identityKey !== resolved.identityKey) {
+                throw new Error(`Cannot resolve generated ${outputName} '${output}' for `
+                    + `'${this.describeTemplate(existing.template)}' and '${this.describeTemplate(resolved.template)}'`);
+            }
+            outputs.set(output, resolved);
+        }
+    }
+    assertDistinctNamespaceAliases(namespaceAliases) {
+        const identitiesByAlias = new Map();
+        for (const [identityKey, alias] of namespaceAliases) {
+            const existingIdentityKey = identitiesByAlias.get(alias);
+            if (existingIdentityKey !== undefined && existingIdentityKey !== identityKey) {
+                throw new Error(`Cannot resolve generated namespace alias '${alias}' for `
+                    + `'${existingIdentityKey.replaceAll("\u0000", ":")}' and `
+                    + `'${identityKey.replaceAll("\u0000", ":")}'`);
+            }
+            identitiesByAlias.set(alias, identityKey);
+        }
+    }
+    getModuleDirectory(moduleName) {
+        return moduleName
             .split(".")
             .map((segment) => this.toKebabCase(segment))
             .join("/");
     }
+    getTemplateFileBaseName(template) {
+        const fileName = this.toKebabCase(template.templateId.templateName);
+        return fileName === "index" || fileName === "types"
+            ? `${fileName}-template`
+            : fileName;
+    }
+    getPackageModuleIdentityKey(template) {
+        return this.getPackageModuleIdentityKeyFromParts(template.templateId.packageId, template.templateId.moduleName);
+    }
+    getPackageModuleIdentityKeyFromParts(packageId, moduleName) {
+        return [packageId, moduleName].join("\u0000");
+    }
+    safeTypeName(value) {
+        const identifier = this.toPascalCase(value);
+        const safeIdentifier = /^[0-9]/.test(identifier) ? `_${identifier}` : identifier;
+        return reservedTypeNames.has(safeIdentifier)
+            ? `${safeIdentifier}Binding`
+            : safeIdentifier;
+    }
+    safeNamespaceAlias(value) {
+        const alias = this.safeTypeName(value);
+        return reservedNamespaceAliases.has(alias)
+            ? `${alias}Namespace`
+            : alias;
+    }
+    safeMemberName(value) {
+        const pascalCase = this.toPascalCase(value);
+        const identifier = `${pascalCase[0].toLowerCase()}${pascalCase.slice(1)}`;
+        const safeIdentifier = /^[0-9]/.test(identifier) ? `_${identifier}` : identifier;
+        return typeScriptKeywords.has(safeIdentifier) || damlTemplateMemberNames.has(safeIdentifier)
+            ? `${safeIdentifier}Value`
+            : safeIdentifier;
+    }
+    toPascalCase(value) {
+        const normalizedValue = value
+            .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+            .replace(/[^A-Za-z0-9]+/g, " ")
+            .trim();
+        if (normalizedValue.length === 0) {
+            throw new Error("Cannot normalize an empty DAML identifier");
+        }
+        return normalizedValue
+            .split(/\s+/)
+            .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+            .join("");
+    }
     toKebabCase(value) {
-        return value
+        return this.toPascalCase(value)
             .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-            .replace(/[^A-Za-z0-9]+/g, "-")
             .toLowerCase();
     }
+    shortHash(value) {
+        let hash = 0x811c9dc5;
+        for (const character of value) {
+            hash ^= character.charCodeAt(0);
+            hash = Math.imul(hash, 0x01000193);
+        }
+        return (hash >>> 0).toString(36).padStart(6, "0").slice(-6);
+    }
+    describeTemplate(template) {
+        return `${template.templateId.packageId}:${template.templateId.moduleName}:${template.templateId.templateName}`;
+    }
 }

package/dist/daml-interface/emission-model/generated-choice-binding.d.ts

@@ -1,18 +1,25 @@
+import { AnalyzedDamlType } from "../analysis/analyzed-daml-type.js";
 export declare class GeneratedChoiceBinding {
+    readonly choiceIdentityKey: string;
     readonly name: string;
     readonly methodName: string;
     readonly choiceTypeName: string;
     readonly exercisedEventTypeName: string;
     readonly parameterName: string;
     readonly parameterTypeName: string;
+    readonly parameterType: AnalyzedDamlType;
     readonly returnTypeName: string;
+    readonly returnType: AnalyzedDamlType;
     constructor(init: {
+        choiceIdentityKey?: string;
         name: string;
         methodName: string;
         choiceTypeName: string;
         exercisedEventTypeName: string;
         parameterName: string;
         parameterTypeName: string;
+        parameterType: AnalyzedDamlType;
         returnTypeName: string;
+        returnType: AnalyzedDamlType;
     });
 }

package/dist/daml-interface/emission-model/generated-choice-binding.js

@@ -1,18 +1,24 @@
 export class GeneratedChoiceBinding {
+    choiceIdentityKey;
     name;
     methodName;
     choiceTypeName;
     exercisedEventTypeName;
     parameterName;
     parameterTypeName;
+    parameterType;
     returnTypeName;
+    returnType;
     constructor(init) {
+        this.choiceIdentityKey = init.choiceIdentityKey ?? init.name;
         this.name = init.name;
         this.methodName = init.methodName;
         this.choiceTypeName = init.choiceTypeName;
         this.exercisedEventTypeName = init.exercisedEventTypeName;
         this.parameterName = init.parameterName;
         this.parameterTypeName = init.parameterTypeName;
+        this.parameterType = init.parameterType;
         this.returnTypeName = init.returnTypeName;
+        this.returnType = init.returnType;
     }
 }

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

@@ -1,13 +1,16 @@
+import { GeneratedNamedTypeFile } from "./generated-named-type-file.js";
 import { GeneratedRegistryFile } from "./generated-registry-file.js";
 import { GeneratedSupportFile } from "./generated-support-file.js";
 import { GeneratedTemplateBindingFile } from "./generated-template-binding-file.js";
 export declare class GeneratedDamlInterfaceProject {
     readonly templateFiles: readonly GeneratedTemplateBindingFile[];
+    readonly namedTypeFiles: readonly GeneratedNamedTypeFile[];
     readonly supportFiles: readonly GeneratedSupportFile[];
     readonly registryFile?: GeneratedRegistryFile;
     readonly indexFile?: GeneratedSupportFile;
     constructor(init: {
         templateFiles: readonly GeneratedTemplateBindingFile[];
+        namedTypeFiles?: readonly GeneratedNamedTypeFile[];
         supportFiles?: readonly GeneratedSupportFile[];
         registryFile?: GeneratedRegistryFile;
         indexFile?: GeneratedSupportFile;

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

@@ -1,10 +1,12 @@
 export class GeneratedDamlInterfaceProject {
     templateFiles;
+    namedTypeFiles;
     supportFiles;
     registryFile;
     indexFile;
     constructor(init) {
         this.templateFiles = init.templateFiles;
+        this.namedTypeFiles = init.namedTypeFiles ?? [];
         this.supportFiles = init.supportFiles ?? [];
         this.registryFile = init.registryFile;
         this.indexFile = init.indexFile;

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

@@ -0,0 +1,23 @@
+/** A generated module containing declarations for one DAML package/module identity. */
+export declare class GeneratedNamedTypeFile {
+    readonly path: string;
+    readonly contents: string;
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly namespaceAlias: string;
+    readonly exportedTypeNames: readonly string[];
+    /** Resolved exported type names keyed by package, module, and DAML entity name. */
+    readonly exportedTypeNamesByIdentity: ReadonlyMap<string, string>;
+    /** Resolved record property names keyed by named type identity, field label, and position. */
+    readonly fieldPropertyNames: ReadonlyMap<string, string>;
+    constructor(init: {
+        path: string;
+        contents: string;
+        packageId: string;
+        moduleName: string;
+        namespaceAlias: string;
+        exportedTypeNames: readonly string[];
+        exportedTypeNamesByIdentity?: ReadonlyMap<string, string>;
+        fieldPropertyNames?: ReadonlyMap<string, string>;
+    });
+}

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

@@ -0,0 +1,23 @@
+/** A generated module containing declarations for one DAML package/module identity. */
+export class GeneratedNamedTypeFile {
+    path;
+    contents;
+    packageId;
+    moduleName;
+    namespaceAlias;
+    exportedTypeNames;
+    /** Resolved exported type names keyed by package, module, and DAML entity name. */
+    exportedTypeNamesByIdentity;
+    /** Resolved record property names keyed by named type identity, field label, and position. */
+    fieldPropertyNames;
+    constructor(init) {
+        this.path = init.path;
+        this.contents = init.contents;
+        this.packageId = init.packageId;
+        this.moduleName = init.moduleName;
+        this.namespaceAlias = init.namespaceAlias;
+        this.exportedTypeNames = init.exportedTypeNames;
+        this.exportedTypeNamesByIdentity = init.exportedTypeNamesByIdentity ?? new Map();
+        this.fieldPropertyNames = init.fieldPropertyNames ?? new Map();
+    }
+}

package/dist/daml-interface/emission-model/generated-template-binding.d.ts

@@ -1,15 +1,22 @@
 import { GeneratedChoiceBinding } from "./generated-choice-binding.js";
+import { AnalyzedDamlType } from "../analysis/analyzed-daml-type.js";
 export declare class GeneratedTemplateBindingField {
     readonly name: string;
     readonly propertyName: string;
+    readonly constructorParameterName: string;
+    readonly type: AnalyzedDamlType;
     readonly typeName: string;
     constructor(init: {
         name: string;
         propertyName: string;
+        constructorParameterName?: string;
+        type: AnalyzedDamlType;
         typeName: string;
     });
 }
 export declare class GeneratedTemplateBinding {
+    readonly templateIdentityKey: string;
+    readonly namespaceAlias: string;
     readonly className: string;
     readonly templateIdLiteral: string;
     readonly path: string;
@@ -18,6 +25,8 @@ export declare class GeneratedTemplateBinding {
     readonly createFields: readonly GeneratedTemplateBindingField[];
     readonly choices: readonly GeneratedChoiceBinding[];
     constructor(init: {
+        templateIdentityKey?: string;
+        namespaceAlias?: string;
         className: string;
         templateIdLiteral: string;
         path: string;

package/dist/daml-interface/emission-model/generated-template-binding.js

@@ -1,14 +1,20 @@
 export class GeneratedTemplateBindingField {
     name;
     propertyName;
+    constructorParameterName;
+    type;
     typeName;
     constructor(init) {
         this.name = init.name;
         this.propertyName = init.propertyName;
+        this.constructorParameterName = init.constructorParameterName ?? init.propertyName;
+        this.type = init.type;
         this.typeName = init.typeName;
     }
 }
 export class GeneratedTemplateBinding {
+    templateIdentityKey;
+    namespaceAlias;
     className;
     templateIdLiteral;
     path;
@@ -17,6 +23,8 @@ export class GeneratedTemplateBinding {
     createFields;
     choices;
     constructor(init) {
+        this.templateIdentityKey = init.templateIdentityKey ?? init.templateIdLiteral;
+        this.namespaceAlias = init.namespaceAlias ?? init.className;
         this.className = init.className;
         this.templateIdLiteral = init.templateIdLiteral;
         this.path = init.path;

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

@@ -7,7 +7,19 @@ export { DamlInterfaceGenerator } from "./daml-interface-generator.js";
 export { DamlInterfaceGeneratorOptions } from "./daml-interface-generator-options.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";
 export { DamlInterfaceGenerationException } from "./errors/daml-interface-generation.exception.js";
 export { DamlInterfaceUnsupportedShapeException } from "./errors/daml-interface-unsupported-shape.exception.js";
 export { DamlInterfaceWriteException } from "./errors/daml-interface-write.exception.js";
 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 { 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 { 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

@@ -7,7 +7,16 @@ export { DamlInterfaceGenerator } from "./daml-interface-generator.js";
 export { DamlInterfaceGeneratorOptions } from "./daml-interface-generator-options.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";
 export { DamlInterfaceGenerationException } from "./errors/daml-interface-generation.exception.js";
 export { DamlInterfaceUnsupportedShapeException } from "./errors/daml-interface-unsupported-shape.exception.js";
 export { DamlInterfaceWriteException } from "./errors/daml-interface-write.exception.js";
 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 { 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";