@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

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

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptNameResolver = void 0;
+const daml_lf_builtin_type_js_1 = require("../../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", "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", "contractId", "templateId", "create", "decodeCreatedEvent",
+    "decodeExercisedEvent",
+]);
+const reservedTypeNames = new Set(["DamlTemplate"]);
+const reservedNamespaceAliases = new Set(["GeneratedRegistry"]);
+class TypeScriptNameResolver {
+    templatesByIdentity = new Map();
+    resolvedTemplates = new Map();
+    resolvedModules = new Map();
+    packageMetadata = new Map();
+    constructor(templates = [], packageMetadata = new Map()) {
+        this.prepareProjectOrThrow(templates, [], packageMetadata);
+    }
+    /** Prepares a project-wide name table and rejects irreconcilable output collisions. */
+    prepareTemplatesOrThrow(templates) {
+        this.prepareProjectOrThrow(templates, [], this.packageMetadata);
+    }
+    /** Prepares shared package/module paths for template and named DAML type output. */
+    prepareProjectOrThrow(templates, typeDefinitions, packageMetadata = new Map()) {
+        this.templatesByIdentity.clear();
+        this.resolvedTemplates.clear();
+        this.resolvedModules.clear();
+        this.packageMetadata = new Map(packageMetadata);
+        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.getPackageDirectoryBaseName(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(`${this.getPackageNamespaceLabel(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 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 `${this.getTemplateClassName(template)}Fields`;
+    }
+    /** Resolves the generated created-event type name for a template. */
+    getCreatedEventTypeName(template) {
+        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 this.getResolvedChoice(template, choice).choiceTypeName;
+    }
+    /** Resolves the generated exercised-event type name for a template choice. */
+    getExercisedEventTypeName(template, choice) {
+        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.kind === "primitive" && type.builtinType === daml_lf_builtin_type_js_1.DamlLfBuiltinType.text
+            ? "string"
+            : "unknown";
+    }
+    /** Resolves the literal template identifier used by generated helpers. */
+    getTemplateIdLiteral(template) {
+        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;
+    }
+    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("/");
+    }
+    getPackageDirectoryBaseName(packageId) {
+        const metadata = this.packageMetadata.get(packageId);
+        if (metadata === undefined
+            || metadata.packageName.trim().length === 0
+            || metadata.packageVersion.trim().length === 0) {
+            return this.toKebabCase(packageId);
+        }
+        return `${this.toPackageNameSegment(metadata.packageName)}_${this.toPackageVersionSegment(metadata.packageVersion)}`;
+    }
+    getPackageNamespaceLabel(packageId) {
+        const packageName = this.packageMetadata.get(packageId)?.packageName.trim();
+        return packageName === undefined || packageName.length === 0
+            ? packageId
+            : packageName;
+    }
+    toPackageNameSegment(value) {
+        const segment = value
+            .trim()
+            .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+            .replace(/[^A-Za-z0-9]+/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "")
+            .toLowerCase();
+        return segment.length === 0 ? "package" : segment;
+    }
+    toPackageVersionSegment(value) {
+        const segment = value
+            .trim()
+            .replace(/[^A-Za-z0-9._-]+/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "");
+        return segment.length === 0 ? "unknown" : segment;
+    }
+    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 this.toPascalCase(value)
+            .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+            .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}`;
+    }
+}
+exports.TypeScriptNameResolver = TypeScriptNameResolver;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedChoiceBinding = void 0;
+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;
+    }
+}
+exports.GeneratedChoiceBinding = GeneratedChoiceBinding;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedDamlInterfaceProject = void 0;
+class GeneratedDamlInterfaceProject {
+    templateFiles;
+    namedTypeFiles;
+    supportFiles;
+    registryFile;
+    indexFile;
+    /** Every non-spec module emitted by this project. */
+    productionFiles;
+    /** Runnable specs, each colocated with exactly one production module. */
+    specFiles;
+    constructor(init) {
+        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);
+        }
+    }
+}
+exports.GeneratedDamlInterfaceProject = GeneratedDamlInterfaceProject;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedNamedTypeFile = void 0;
+/** A generated module containing declarations for one DAML package/module identity. */
+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();
+    }
+}
+exports.GeneratedNamedTypeFile = GeneratedNamedTypeFile;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedRegistryFile = void 0;
+class GeneratedRegistryFile {
+    path;
+    contents;
+    constructor(init) {
+        this.path = init.path;
+        this.contents = init.contents;
+    }
+}
+exports.GeneratedRegistryFile = GeneratedRegistryFile;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedSpecFile = void 0;
+/** A runnable Node test generated beside one production DAML module. */
+class GeneratedSpecFile {
+    path;
+    contents;
+    productionPath;
+    constructor(path, contents, productionPath) {
+        this.path = path;
+        this.contents = contents;
+        this.productionPath = productionPath;
+    }
+}
+exports.GeneratedSpecFile = GeneratedSpecFile;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedSupportFile = void 0;
+class GeneratedSupportFile {
+    path;
+    contents;
+    constructor(init) {
+        this.path = init.path;
+        this.contents = init.contents;
+    }
+}
+exports.GeneratedSupportFile = GeneratedSupportFile;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedTemplateBindingFile = void 0;
+class GeneratedTemplateBindingFile {
+    path;
+    contents;
+    binding;
+    constructor(init) {
+        this.path = init.path;
+        this.contents = init.contents;
+        this.binding = init.binding;
+    }
+}
+exports.GeneratedTemplateBindingFile = GeneratedTemplateBindingFile;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedTemplateBinding = exports.GeneratedTemplateBindingField = void 0;
+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;
+    }
+}
+exports.GeneratedTemplateBindingField = GeneratedTemplateBindingField;
+class GeneratedTemplateBinding {
+    templateIdentityKey;
+    namespaceAlias;
+    className;
+    templateIdLiteral;
+    path;
+    createFieldsTypeName;
+    createdEventTypeName;
+    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;
+        this.createFieldsTypeName = init.createFieldsTypeName;
+        this.createdEventTypeName = init.createdEventTypeName;
+        this.createFields = init.createFields;
+        this.choices = init.choices;
+    }
+}
+exports.GeneratedTemplateBinding = GeneratedTemplateBinding;

package/dist/cjs/daml-interface/errors/daml-interface-generation.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceGenerationException = void 0;
+class DamlInterfaceGenerationException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DamlInterfaceGenerationException";
+    }
+}
+exports.DamlInterfaceGenerationException = DamlInterfaceGenerationException;