@distrohelena/canton-typescript-sdk 0.1.0

package/dist/daml-interface/analysis/daml-interface-analyzer.js

@@ -0,0 +1,81 @@
+import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
+import { DamlInterfaceUnsupportedShapeException } from "../errors/daml-interface-unsupported-shape.exception.js";
+import { AnalyzedChoice } from "./analyzed-choice.js";
+import { AnalyzedTemplate, AnalyzedTemplateField } from "./analyzed-template.js";
+export class DamlInterfaceAnalysisResult {
+    templates;
+    constructor(init) {
+        this.templates = init.templates;
+    }
+}
+export class DamlInterfaceAnalyzer {
+    /** Analyzes compiled DAML-LF templates into generator-facing metadata. */
+    analyzeOrThrow(compilation) {
+        const semanticModel = compilation.createSemanticModel();
+        const templates = semanticModel
+            .getTemplates()
+            .map((item) => this.analyzeTemplateOrThrow(item));
+        return new DamlInterfaceAnalysisResult({
+            templates,
+        });
+    }
+    analyzeTemplateOrThrow(template) {
+        return new AnalyzedTemplate({
+            templateId: template.templateId,
+            className: this.toPascalCase(template.name),
+            fileName: `${this.toKebabCase(template.name)}.ts`,
+            createFields: template.fields.map((item) => this.analyzeTemplateFieldOrThrow(item)),
+            choices: template.choices.map((item) => this.analyzeChoiceOrThrow(item)),
+        });
+    }
+    analyzeTemplateFieldOrThrow(field) {
+        this.assertSupportedTypeOrThrow(field.type, `template field '${field.name}'`);
+        return new AnalyzedTemplateField({
+            name: field.name,
+            propertyName: this.toCamelCase(field.name),
+            type: field.type,
+        });
+    }
+    analyzeChoiceOrThrow(choice) {
+        this.assertSupportedTypeOrThrow(choice.parameter.type, `choice parameter '${choice.parameter.name}'`);
+        this.assertSupportedTypeOrThrow(choice.returnType, `choice return type '${choice.name}'`);
+        return new AnalyzedChoice({
+            name: choice.name,
+            methodName: `exercise${this.toPascalCase(choice.name)}`,
+            parameterName: this.toCamelCase(choice.parameter.name),
+            parameterType: choice.parameter.type,
+            returnType: choice.returnType,
+        });
+    }
+    assertSupportedTypeOrThrow(type, context) {
+        if (type.typeConReference !== undefined ||
+            type.builtinType !== DamlLfBuiltinType.text) {
+            throw new DamlInterfaceUnsupportedShapeException(`${context} is not supported yet by the DAML interface generator`);
+        }
+    }
+    toCamelCase(value) {
+        const pascalCase = this.toPascalCase(value);
+        if (pascalCase.length === 0) {
+            throw new DamlInterfaceUnsupportedShapeException("DAML interface generator cannot normalize an empty identifier");
+        }
+        return pascalCase[0].toLowerCase() + pascalCase.slice(1);
+    }
+    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 DamlInterfaceUnsupportedShapeException("DAML interface generator cannot normalize an empty 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();
+    }
+}

package/dist/daml-interface/cli/daml-interface-cli-main.d.ts

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

package/dist/daml-interface/cli/daml-interface-cli-main.js

@@ -0,0 +1,3 @@
+import { DamlInterfaceCli } from "./daml-interface-cli.js";
+const exitCode = await new DamlInterfaceCli().runAsync(process.argv.slice(2));
+process.exitCode = exitCode;

package/dist/daml-interface/cli/daml-interface-cli-options.d.ts

@@ -0,0 +1,10 @@
+export declare class DamlInterfaceCliOptions {
+    readonly inputPath: string;
+    readonly outputDirectory: string;
+    constructor(init: {
+        inputPath: string;
+        outputDirectory: string;
+    });
+    /** Parses CLI arguments into strongly typed DAML interface generation options. */
+    static parseOrThrow(args: readonly string[]): DamlInterfaceCliOptions;
+}

package/dist/daml-interface/cli/daml-interface-cli-options.js

@@ -0,0 +1,33 @@
+import { DamlInterfaceGenerationException } from "../errors/daml-interface-generation.exception.js";
+export class DamlInterfaceCliOptions {
+    inputPath;
+    outputDirectory;
+    constructor(init) {
+        this.inputPath = init.inputPath;
+        this.outputDirectory = init.outputDirectory;
+    }
+    /** Parses CLI arguments into strongly typed DAML interface generation options. */
+    static parseOrThrow(args) {
+        let inputPath;
+        let outputDirectory;
+        for (let index = 0; index < args.length; index++) {
+            const current = args[index];
+            const next = args[index + 1];
+            if (current === "--input") {
+                inputPath = next;
+                index++;
+            }
+            else if (current === "--output") {
+                outputDirectory = next;
+                index++;
+            }
+        }
+        if (inputPath === undefined || outputDirectory === undefined) {
+            throw new DamlInterfaceGenerationException("daml interface cli requires --input and --output");
+        }
+        return new DamlInterfaceCliOptions({
+            inputPath,
+            outputDirectory,
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+import { DamlInterfaceGenerator } from "../daml-interface-generator.js";
+import { DamlInterfaceWriter } from "../writing/daml-interface-writer.js";
+export declare class DamlInterfaceCli {
+    private readonly generator;
+    private readonly writer;
+    private readonly readFileAsync;
+    constructor(generator?: DamlInterfaceGenerator, writer?: DamlInterfaceWriter, readFileAsync?: (path: string) => Promise<Uint8Array>);
+    /** Runs the DAML interface CLI and returns a process exit code. */
+    runAsync(args: readonly string[]): Promise<number>;
+}

package/dist/daml-interface/cli/daml-interface-cli.js

@@ -0,0 +1,35 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { DamlInterfaceGenerator } from "../daml-interface-generator.js";
+import { DamlInterfaceGenerationException } from "../errors/daml-interface-generation.exception.js";
+import { DamlInterfaceCliOptions } from "./daml-interface-cli-options.js";
+import { DamlInterfaceWriter } from "../writing/daml-interface-writer.js";
+export class DamlInterfaceCli {
+    generator;
+    writer;
+    readFileAsync;
+    constructor(generator = new DamlInterfaceGenerator(), writer = new DamlInterfaceWriter(), readFileAsync = readFile) {
+        this.generator = generator;
+        this.writer = writer;
+        this.readFileAsync = readFileAsync;
+        void this.generator;
+        void this.writer;
+        void this.readFileAsync;
+    }
+    /** Runs the DAML interface CLI and returns a process exit code. */
+    async runAsync(args) {
+        const options = DamlInterfaceCliOptions.parseOrThrow(args);
+        const bytes = await this.readFileAsync(options.inputPath);
+        const extension = extname(options.inputPath).toLowerCase();
+        const project = extension === ".dar"
+            ? await this.generator.generateFromDarOrThrowAsync(bytes)
+            : extension === ".dalf"
+                ? await this.generator.generateFromDalfOrThrowAsync(bytes)
+                : undefined;
+        if (project === undefined) {
+            throw new DamlInterfaceGenerationException(`daml interface cli does not support '${extension}' inputs`);
+        }
+        await this.writer.writeProjectAsync(project, options.outputDirectory);
+        return 0;
+    }
+}

package/dist/daml-interface/daml-interface-generator-options.d.ts

@@ -0,0 +1,6 @@
+export declare class DamlInterfaceGeneratorOptions {
+    readonly generatedDirectory: string;
+    constructor(init?: {
+        generatedDirectory?: string;
+    });
+}

package/dist/daml-interface/daml-interface-generator-options.js

@@ -0,0 +1,6 @@
+export class DamlInterfaceGeneratorOptions {
+    generatedDirectory;
+    constructor(init = {}) {
+        this.generatedDirectory = init.generatedDirectory ?? "generated";
+    }
+}

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

@@ -0,0 +1,21 @@
+import { DarArchiveLoader } from "../daml-lf/container/dar-archive-loader.js";
+import { DamlLfCompilation } from "../daml-lf/daml-lf-compilation.js";
+import { DamlLfPackageLoader } from "../daml-lf/daml-lf-package-loader.js";
+import { DamlInterfaceAnalysisResult, DamlInterfaceAnalyzer } from "./analysis/daml-interface-analyzer.js";
+import { DamlInterfaceGeneratorOptions } from "./daml-interface-generator-options.js";
+import { GeneratedDamlInterfaceProject } from "./emission-model/generated-daml-interface-project.js";
+import { ProjectEmitter } from "./emission/project-emitter.js";
+export declare class DamlInterfaceGenerator {
+    private readonly analyzer;
+    private readonly projectEmitter;
+    private readonly darArchiveLoader;
+    private readonly packageLoader;
+    readonly options: DamlInterfaceGeneratorOptions;
+    constructor(options?: DamlInterfaceGeneratorOptions, analyzer?: DamlInterfaceAnalyzer, projectEmitter?: ProjectEmitter, darArchiveLoader?: DarArchiveLoader, packageLoader?: DamlLfPackageLoader);
+    /** Analyzes a compiled DAML-LF workspace with the package generator rules. */
+    analyzeOrThrow(compilation: DamlLfCompilation): DamlInterfaceAnalysisResult;
+    /** Generates an in-memory project from compiled DAML-LF archive bytes. */
+    generateFromDalfOrThrowAsync(archiveBytes: Uint8Array): Promise<GeneratedDamlInterfaceProject>;
+    /** Generates an in-memory project from DAR bytes. */
+    generateFromDarOrThrowAsync(archiveBytes: Uint8Array): Promise<GeneratedDamlInterfaceProject>;
+}

package/dist/daml-interface/daml-interface-generator.js

@@ -0,0 +1,42 @@
+import { DarArchiveLoader } from "../daml-lf/container/dar-archive-loader.js";
+import { DamlLfCompilation } from "../daml-lf/daml-lf-compilation.js";
+import { DamlLfPackageLoader } from "../daml-lf/daml-lf-package-loader.js";
+import { DamlLfWorkspace } from "../daml-lf/daml-lf-workspace.js";
+import { DamlInterfaceAnalyzer, } from "./analysis/daml-interface-analyzer.js";
+import { DamlInterfaceGeneratorOptions } from "./daml-interface-generator-options.js";
+import { ProjectEmitter } from "./emission/project-emitter.js";
+export class DamlInterfaceGenerator {
+    analyzer;
+    projectEmitter;
+    darArchiveLoader;
+    packageLoader;
+    options;
+    constructor(options = new DamlInterfaceGeneratorOptions(), analyzer = new DamlInterfaceAnalyzer(), projectEmitter = new ProjectEmitter(), darArchiveLoader = new DarArchiveLoader(), packageLoader = new DamlLfPackageLoader()) {
+        this.analyzer = analyzer;
+        this.projectEmitter = projectEmitter;
+        this.darArchiveLoader = darArchiveLoader;
+        this.packageLoader = packageLoader;
+        this.options = options;
+        void this.analyzer;
+        void this.projectEmitter;
+        void this.darArchiveLoader;
+        void this.packageLoader;
+    }
+    /** Analyzes a compiled DAML-LF workspace with the package generator rules. */
+    analyzeOrThrow(compilation) {
+        return this.analyzer.analyzeOrThrow(compilation);
+    }
+    /** Generates an in-memory project from compiled DAML-LF archive bytes. */
+    async generateFromDalfOrThrowAsync(archiveBytes) {
+        const pkg = this.packageLoader.loadPackageOrThrow(archiveBytes);
+        const compilation = DamlLfCompilation.createOrThrow(new DamlLfWorkspace([pkg]));
+        return this.projectEmitter.emitProject(this.analyzeOrThrow(compilation));
+    }
+    /** Generates an in-memory project from DAR bytes. */
+    async generateFromDarOrThrowAsync(archiveBytes) {
+        const archive = await this.darArchiveLoader.loadDarOrThrowAsync(archiveBytes);
+        const packages = archive.packageEntries.map((entry) => this.packageLoader.loadPackageOrThrow(entry.bytes));
+        const compilation = DamlLfCompilation.createOrThrow(new DamlLfWorkspace(packages));
+        return this.projectEmitter.emitProject(this.analyzeOrThrow(compilation));
+    }
+}

package/dist/daml-interface/emission/project-emitter.d.ts

@@ -0,0 +1,13 @@
+import { DamlInterfaceAnalysisResult } from "../analysis/daml-interface-analyzer.js";
+import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { RegistryEmitter } from "./registry-emitter.js";
+import { SupportFileEmitter } from "./support-file-emitter.js";
+import { TemplateBindingEmitter } from "./template-binding-emitter.js";
+export declare class ProjectEmitter {
+    private readonly templateBindingEmitter;
+    private readonly supportFileEmitter;
+    private readonly registryEmitter;
+    constructor(templateBindingEmitter?: TemplateBindingEmitter, supportFileEmitter?: SupportFileEmitter, registryEmitter?: RegistryEmitter);
+    /** Emits the complete in-memory DAML interface project from analyzed templates. */
+    emitProject(analysis: DamlInterfaceAnalysisResult): GeneratedDamlInterfaceProject;
+}

package/dist/daml-interface/emission/project-emitter.js

@@ -0,0 +1,39 @@
+import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { RegistryEmitter } from "./registry-emitter.js";
+import { SupportFileEmitter } from "./support-file-emitter.js";
+import { TemplateBindingEmitter } from "./template-binding-emitter.js";
+export class ProjectEmitter {
+    templateBindingEmitter;
+    supportFileEmitter;
+    registryEmitter;
+    constructor(templateBindingEmitter = new TemplateBindingEmitter(), supportFileEmitter = new SupportFileEmitter(), registryEmitter = new RegistryEmitter()) {
+        this.templateBindingEmitter = templateBindingEmitter;
+        this.supportFileEmitter = supportFileEmitter;
+        this.registryEmitter = registryEmitter;
+        void this.templateBindingEmitter;
+        void this.supportFileEmitter;
+        void this.registryEmitter;
+    }
+    /** Emits the complete in-memory DAML interface project from analyzed templates. */
+    emitProject(analysis) {
+        const templateFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateFile(template));
+        const supportFiles = this.supportFileEmitter.emitSupportFiles();
+        const baseProject = new GeneratedDamlInterfaceProject({
+            templateFiles,
+            supportFiles,
+        });
+        const registryFile = this.registryEmitter.emitRegistry(baseProject);
+        const projectWithRegistry = new GeneratedDamlInterfaceProject({
+            templateFiles,
+            supportFiles,
+            registryFile,
+        });
+        const indexFile = this.supportFileEmitter.emitIndexFile(projectWithRegistry);
+        return new GeneratedDamlInterfaceProject({
+            templateFiles,
+            supportFiles,
+            registryFile,
+            indexFile,
+        });
+    }
+}

package/dist/daml-interface/emission/registry-emitter.d.ts

@@ -0,0 +1,6 @@
+import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { GeneratedRegistryFile } from "../emission-model/generated-registry-file.js";
+export declare class RegistryEmitter {
+    /** Emits a registry that dispatches created and exercised events by template id. */
+    emitRegistry(project: GeneratedDamlInterfaceProject): GeneratedRegistryFile;
+}

package/dist/daml-interface/emission/registry-emitter.js

@@ -0,0 +1,39 @@
+import { GeneratedRegistryFile } from "../emission-model/generated-registry-file.js";
+export class RegistryEmitter {
+    /** Emits a registry that dispatches created and exercised events by template id. */
+    emitRegistry(project) {
+        const importLines = project.templateFiles.map((file) => {
+            const modulePath = file.path
+                .replace(/^generated\//, "./")
+                .replace(/\.ts$/, ".js");
+            return `import { ${file.binding.className} } from "${modulePath}";`;
+        });
+        const createdCases = project.templateFiles.map((file) => `            case "${file.binding.templateIdLiteral}":\n                return ${file.binding.className}.decodeCreatedEvent(event);`);
+        const exercisedCases = project.templateFiles.map((file) => `            case "${file.binding.templateIdLiteral}":\n                return ${file.binding.className}.decodeExercisedEvent(event);`);
+        return new GeneratedRegistryFile({
+            path: "generated/registry.ts",
+            contents: [
+                ...importLines,
+                "",
+                "export class GeneratedRegistry {",
+                "    public static decodeCreatedEvent(templateId: string, event: unknown): unknown {",
+                "        switch (templateId) {",
+                ...createdCases,
+                "            default:",
+                "                return event;",
+                "        }",
+                "    }",
+                "",
+                "    public static decodeExercisedEvent(templateId: string, event: unknown): unknown {",
+                "        switch (templateId) {",
+                ...exercisedCases,
+                "            default:",
+                "                return event;",
+                "        }",
+                "    }",
+                "}",
+                "",
+            ].join("\n"),
+        });
+    }
+}

package/dist/daml-interface/emission/support-file-emitter.d.ts

@@ -0,0 +1,8 @@
+import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { GeneratedSupportFile } from "../emission-model/generated-support-file.js";
+export declare class SupportFileEmitter {
+    /** Emits shared support files for the generated DAML interface project. */
+    emitSupportFiles(): readonly GeneratedSupportFile[];
+    /** Emits the generated project index file. */
+    emitIndexFile(project: GeneratedDamlInterfaceProject): GeneratedSupportFile;
+}

package/dist/daml-interface/emission/support-file-emitter.js

@@ -0,0 +1,30 @@
+import { GeneratedSupportFile } from "../emission-model/generated-support-file.js";
+export class SupportFileEmitter {
+    /** Emits shared support files for the generated DAML interface project. */
+    emitSupportFiles() {
+        return [
+            new GeneratedSupportFile({
+                path: "generated/support/contracts.ts",
+                contents: "export type GeneratedContractId = string;\n",
+            }),
+            new GeneratedSupportFile({
+                path: "generated/support/decoding.ts",
+                contents: "export function castGeneratedEvent<T>(event: unknown): T {\n    return event as T;\n}\n",
+            }),
+        ];
+    }
+    /** Emits the generated project index file. */
+    emitIndexFile(project) {
+        const exportLines = project.templateFiles
+            .map((file) => file.path.replace(/^generated\//, "./").replace(/\.ts$/, ".js"))
+            .map((path) => `export * from "${path}";`);
+        const lines = [
+            ...exportLines,
+            'export * from "./registry.js";',
+        ];
+        return new GeneratedSupportFile({
+            path: "generated/index.ts",
+            contents: `${lines.join("\n")}\n`,
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AnalyzedTemplate } from "../analysis/analyzed-template.js";
+import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
+import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+export declare class TemplateBindingEmitter {
+    private readonly nameResolver;
+    constructor(nameResolver?: TypeScriptNameResolver);
+    /** Emits a generated TypeScript file for one analyzed DAML template. */
+    emitTemplateFile(template: AnalyzedTemplate): GeneratedTemplateBindingFile;
+    private createBinding;
+    private emitContents;
+}

package/dist/daml-interface/emission/template-binding-emitter.js

@@ -0,0 +1,119 @@
+import { GeneratedChoiceBinding } from "../emission-model/generated-choice-binding.js";
+import { GeneratedTemplateBinding } from "../emission-model/generated-template-binding.js";
+import { GeneratedTemplateBindingField, } from "../emission-model/generated-template-binding.js";
+import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
+import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+export class TemplateBindingEmitter {
+    nameResolver;
+    constructor(nameResolver = new TypeScriptNameResolver()) {
+        this.nameResolver = nameResolver;
+        void this.nameResolver;
+    }
+    /** Emits a generated TypeScript file for one analyzed DAML template. */
+    emitTemplateFile(template) {
+        const binding = this.createBinding(template);
+        const contents = this.emitContents(binding);
+        return new GeneratedTemplateBindingFile({
+            path: binding.path,
+            contents,
+            binding,
+        });
+    }
+    createBinding(template) {
+        return new GeneratedTemplateBinding({
+            className: template.className,
+            templateIdLiteral: this.nameResolver.getTemplateIdLiteral(template),
+            path: this.nameResolver.getTemplateFilePath(template),
+            createFieldsTypeName: this.nameResolver.getCreateFieldsTypeName(template),
+            createdEventTypeName: this.nameResolver.getCreatedEventTypeName(template),
+            createFields: template.createFields.map((field) => new GeneratedTemplateBindingField({
+                name: field.name,
+                propertyName: field.propertyName,
+                typeName: this.nameResolver.getTypeName(field.type),
+            })),
+            choices: template.choices.map((choice) => new GeneratedChoiceBinding({
+                name: choice.name,
+                methodName: choice.methodName,
+                choiceTypeName: this.nameResolver.getChoiceTypeName(template, choice),
+                exercisedEventTypeName: this.nameResolver.getExercisedEventTypeName(template, choice),
+                parameterName: choice.parameterName,
+                parameterTypeName: this.nameResolver.getTypeName(choice.parameterType),
+                returnTypeName: this.nameResolver.getTypeName(choice.returnType),
+            })),
+        });
+    }
+    emitContents(binding) {
+        const createFields = binding.createFields
+            .map((field) => `    ${field.propertyName}: ${field.typeName};`)
+            .join("\n");
+        const choiceInterfaces = binding.choices
+            .map((choice) => [
+            `export interface ${choice.choiceTypeName} {`,
+            `    ${choice.parameterName}: ${choice.parameterTypeName};`,
+            "}",
+        ].join("\n"))
+            .join("\n\n");
+        const exercisedEvents = binding.choices
+            .map((choice) => [
+            `export interface ${choice.exercisedEventTypeName} {`,
+            `    choiceName: "${choice.name}";`,
+            `    result: ${choice.returnTypeName};`,
+            "}",
+        ].join("\n"))
+            .join("\n\n");
+        const choiceMethods = binding.choices
+            .map((choice) => [
+            `    public static ${choice.methodName}(`,
+            "        contractId: string,",
+            `        choice: ${choice.choiceTypeName},`,
+            "    ): unknown {",
+            "        return {",
+            "            contractId,",
+            `            choiceName: "${choice.name}",`,
+            "            choice,",
+            "        };",
+            "    }",
+        ].join("\n"))
+            .join("\n\n");
+        const exercisedReturnType = binding.choices.length === 1
+            ? binding.choices[0].exercisedEventTypeName
+            : binding.choices
+                .map((choice) => choice.exercisedEventTypeName)
+                .join(" | ");
+        return [
+            `export interface ${binding.createFieldsTypeName} {`,
+            createFields,
+            "}",
+            "",
+            choiceInterfaces,
+            "",
+            `export interface ${binding.createdEventTypeName} {`,
+            "    templateId: string;",
+            `    payload: ${binding.createFieldsTypeName};`,
+            "}",
+            "",
+            exercisedEvents,
+            "",
+            `export class ${binding.className} {`,
+            `    public static readonly templateId = "${binding.templateIdLiteral}";`,
+            "",
+            `    public static create(fields: ${binding.createFieldsTypeName}): unknown {`,
+            "        return {",
+            `            templateId: ${binding.className}.templateId,`,
+            "            fields,",
+            "        };",
+            "    }",
+            "",
+            choiceMethods,
+            "",
+            `    public static decodeCreatedEvent(event: unknown): ${binding.createdEventTypeName} {`,
+            `        return event as ${binding.createdEventTypeName};`,
+            "    }",
+            "",
+            `    public static decodeExercisedEvent(event: unknown): ${exercisedReturnType} {`,
+            `        return event as ${exercisedReturnType};`,
+            "    }",
+            "}",
+        ].filter((item) => item.length > 0).join("\n");
+    }
+}

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

@@ -0,0 +1,21 @@
+import { DamlLfType } from "../../daml-lf/model/daml-lf-type.js";
+import { AnalyzedChoice } from "../analysis/analyzed-choice.js";
+import { AnalyzedTemplate } from "../analysis/analyzed-template.js";
+export declare class TypeScriptNameResolver {
+    /** Resolves the generated file path for a template binding. */
+    getTemplateFilePath(template: AnalyzedTemplate): string;
+    /** Resolves the generated create-fields type name for a template. */
+    getCreateFieldsTypeName(template: AnalyzedTemplate): string;
+    /** Resolves the generated created-event type name for a template. */
+    getCreatedEventTypeName(template: AnalyzedTemplate): string;
+    /** Resolves the generated choice payload type name for a template choice. */
+    getChoiceTypeName(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
+    /** Resolves the generated exercised-event type name for a template choice. */
+    getExercisedEventTypeName(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
+    /** Resolves the TypeScript type name for a supported DAML-LF type. */
+    getTypeName(type: DamlLfType): string;
+    /** Resolves the literal template identifier used by generated helpers. */
+    getTemplateIdLiteral(template: AnalyzedTemplate): string;
+    private getModuleDirectory;
+    private toKebabCase;
+}

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

@@ -0,0 +1,43 @@
+import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
+export class TypeScriptNameResolver {
+    /** Resolves the generated file path for a template binding. */
+    getTemplateFilePath(template) {
+        return `generated/${this.getModuleDirectory(template)}/${template.fileName}`;
+    }
+    /** Resolves the generated create-fields type name for a template. */
+    getCreateFieldsTypeName(template) {
+        return `${template.className}CreateFields`;
+    }
+    /** Resolves the generated created-event type name for a template. */
+    getCreatedEventTypeName(template) {
+        return `${template.className}CreatedEvent`;
+    }
+    /** Resolves the generated choice payload type name for a template choice. */
+    getChoiceTypeName(template, choice) {
+        return `${template.className}${choice.name}Choice`;
+    }
+    /** Resolves the generated exercised-event type name for a template choice. */
+    getExercisedEventTypeName(template, choice) {
+        return `${template.className}${choice.name}ExercisedEvent`;
+    }
+    /** Resolves the TypeScript type name for a supported DAML-LF type. */
+    getTypeName(type) {
+        return type.builtinType === DamlLfBuiltinType.text ? "string" : "unknown";
+    }
+    /** Resolves the literal template identifier used by generated helpers. */
+    getTemplateIdLiteral(template) {
+        return `${template.templateId.moduleName}:${template.templateId.templateName}`;
+    }
+    getModuleDirectory(template) {
+        return template.templateId.moduleName
+            .split(".")
+            .map((segment) => this.toKebabCase(segment))
+            .join("/");
+    }
+    toKebabCase(value) {
+        return value
+            .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+            .replace(/[^A-Za-z0-9]+/g, "-")
+            .toLowerCase();
+    }
+}

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

@@ -0,0 +1,18 @@
+export declare class GeneratedChoiceBinding {
+    readonly name: string;
+    readonly methodName: string;
+    readonly choiceTypeName: string;
+    readonly exercisedEventTypeName: string;
+    readonly parameterName: string;
+    readonly parameterTypeName: string;
+    readonly returnTypeName: string;
+    constructor(init: {
+        name: string;
+        methodName: string;
+        choiceTypeName: string;
+        exercisedEventTypeName: string;
+        parameterName: string;
+        parameterTypeName: string;
+        returnTypeName: string;
+    });
+}

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

@@ -0,0 +1,18 @@
+export class GeneratedChoiceBinding {
+    name;
+    methodName;
+    choiceTypeName;
+    exercisedEventTypeName;
+    parameterName;
+    parameterTypeName;
+    returnTypeName;
+    constructor(init) {
+        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.returnTypeName = init.returnTypeName;
+    }
+}