@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfCompilation = void 0;
+const daml_lf_resolution_exception_js_1 = require("./errors/daml-lf-resolution.exception.js");
+const daml_lf_semantic_exception_js_1 = require("./errors/daml-lf-semantic.exception.js");
+const daml_lf_builtin_type_js_1 = require("./model/daml-lf-builtin-type.js");
+const daml_lf_data_type_js_1 = require("./model/daml-lf-data-type.js");
+const daml_lf_template_js_1 = require("./model/daml-lf-template.js");
+const daml_lf_value_definition_js_1 = require("./model/daml-lf-value-definition.js");
+const module_reference_js_1 = require("./model/module-reference.js");
+const daml_lf_semantic_model_js_1 = require("./semantics/daml-lf-semantic-model.js");
+const module_symbol_js_1 = require("./symbols/module-symbol.js");
+const type_symbol_js_1 = require("./symbols/type-symbol.js");
+class DamlLfCompilation {
+    workspace;
+    moduleSymbols = new Map();
+    typeSymbols = new Map();
+    templates = new Map();
+    valueDefinitions = new Map();
+    valueDefinitionIdentities = new Map();
+    constructor(workspace) {
+        this.workspace = workspace;
+        void this.workspace;
+    }
+    static createOrThrow(workspace) {
+        const compilation = new DamlLfCompilation(workspace);
+        compilation.buildIndexes();
+        compilation.validateReferencesOrThrow();
+        return compilation;
+    }
+    static createForTemplateGeneration(workspace) {
+        const compilation = new DamlLfCompilation(workspace);
+        compilation.buildIndexes();
+        return compilation;
+    }
+    getModuleSymbolOrThrow(reference) {
+        const symbol = this.moduleSymbols.get(DamlLfCompilation.createModuleKey(reference.packageId, reference.moduleName));
+        if (symbol === undefined) {
+            throw new daml_lf_resolution_exception_js_1.DamlLfResolutionException(`could not resolve module '${reference.moduleName}' in package '${reference.packageId}'`);
+        }
+        return symbol;
+    }
+    getTypeSymbolOrThrow(reference) {
+        const symbol = this.typeSymbols.get(DamlLfCompilation.createTypeKey(reference.packageId, reference.moduleName, reference.name));
+        if (symbol === undefined) {
+            throw new daml_lf_resolution_exception_js_1.DamlLfResolutionException(`could not resolve type '${reference.name}' in module '${reference.moduleName}'`);
+        }
+        return symbol;
+    }
+    createSemanticModel() {
+        return new daml_lf_semantic_model_js_1.DamlLfSemanticModel(this);
+    }
+    getValueDefinitionOrThrow(packageId, moduleName, definitionName) {
+        const definition = this.valueDefinitions.get(DamlLfCompilation.createDefinitionKey(packageId, moduleName, definitionName));
+        if (definition === undefined) {
+            throw new daml_lf_resolution_exception_js_1.DamlLfResolutionException(`could not resolve value definition '${definitionName}' in module '${moduleName}'`);
+        }
+        return definition;
+    }
+    getModuleOrThrow(packageId, moduleName) {
+        return this.getModuleSymbolOrThrow(new module_reference_js_1.ModuleReference({
+            packageId,
+            moduleName,
+        })).module;
+    }
+    getValueDefinitionIdentityOrThrow(definition) {
+        const identity = this.valueDefinitionIdentities.get(definition);
+        if (identity === undefined) {
+            throw new daml_lf_resolution_exception_js_1.DamlLfResolutionException(`could not resolve identity for value definition '${definition.name}'`);
+        }
+        return identity;
+    }
+    getTemplates() {
+        return [...this.templates.values()];
+    }
+    /** Returns the packages available to this compilation. */
+    getPackages() {
+        return this.workspace.packages;
+    }
+    getTemplateChoicesOrThrow(templateId) {
+        return this.getTemplateOrThrow(templateId).choices;
+    }
+    buildIndexes() {
+        for (const pkg of this.workspace.packages) {
+            for (const module of pkg.modules) {
+                this.moduleSymbols.set(DamlLfCompilation.createModuleKey(pkg.packageId, module.name), new module_symbol_js_1.ModuleSymbol({
+                    name: module.name,
+                    module,
+                }));
+                for (const definition of module.definitions) {
+                    if (definition instanceof daml_lf_data_type_js_1.DamlLfDataType) {
+                        this.typeSymbols.set(DamlLfCompilation.createTypeKey(pkg.packageId, module.name, definition.name), new type_symbol_js_1.TypeSymbol({
+                            name: definition.name,
+                            definition,
+                        }));
+                    }
+                    if (definition instanceof daml_lf_value_definition_js_1.DamlLfValueDefinition) {
+                        const identity = {
+                            packageId: pkg.packageId,
+                            moduleName: module.name,
+                            definitionName: definition.name,
+                        };
+                        this.valueDefinitions.set(DamlLfCompilation.createDefinitionKey(identity.packageId, identity.moduleName, identity.definitionName), definition);
+                        this.valueDefinitionIdentities.set(definition, identity);
+                    }
+                    if (definition instanceof daml_lf_template_js_1.DamlLfTemplate) {
+                        this.templates.set(DamlLfCompilation.createTemplateKey(definition.templateId), definition);
+                    }
+                }
+            }
+        }
+    }
+    validateReferencesOrThrow() {
+        for (const pkg of this.workspace.packages) {
+            for (const module of pkg.modules) {
+                for (const definition of module.definitions) {
+                    if (definition instanceof daml_lf_value_definition_js_1.DamlLfValueDefinition) {
+                        this.validateTypeOrThrow(definition.type);
+                    }
+                    if (definition instanceof daml_lf_data_type_js_1.DamlLfDataType) {
+                        this.validateDataTypeOrThrow(definition);
+                    }
+                    if (definition instanceof daml_lf_template_js_1.DamlLfTemplate) {
+                        this.getTypeSymbolOrThrow(definition.templateId.toTypeConReference());
+                        for (const field of definition.fields) {
+                            this.validateTypeOrThrow(field.type);
+                        }
+                        for (const choice of definition.choices) {
+                            this.validateTypeOrThrow(choice.parameter.type);
+                            this.validateTypeOrThrow(choice.returnType);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    validateTypeOrThrow(type) {
+        if (type.builtinType === daml_lf_builtin_type_js_1.DamlLfBuiltinType.contractId) {
+            if (type.typeArguments.length !== 1) {
+                throw new daml_lf_semantic_exception_js_1.DamlLfSemanticException("builtin 'contractId' requires 1 type argument");
+            }
+            return;
+        }
+        for (const typeArgument of type.typeArguments) {
+            this.validateTypeOrThrow(typeArgument);
+        }
+        const reference = type.typeConReference;
+        if (reference === undefined) {
+            return;
+        }
+        this.getTypeSymbolOrThrow(reference);
+    }
+    validateDataTypeOrThrow(definition) {
+        if (definition.definition.kind === "record") {
+            for (const field of definition.definition.fields) {
+                this.validateTypeOrThrow(field.type);
+            }
+            return;
+        }
+        else if (definition.definition.kind === "variant") {
+            for (const constructor of definition.definition.constructors) {
+                this.validateTypeOrThrow(constructor.type);
+            }
+        }
+    }
+    static createModuleKey(packageId, moduleName) {
+        return `${packageId}::${moduleName}`;
+    }
+    static createTypeKey(packageId, moduleName, name) {
+        return `${packageId}::${moduleName}::${name}`;
+    }
+    static createDefinitionKey(packageId, moduleName, definitionName) {
+        return `${packageId}::${moduleName}::${definitionName}`;
+    }
+    getTemplateOrThrow(templateId) {
+        const template = this.templates.get(DamlLfCompilation.createTemplateKey(templateId));
+        if (template === undefined) {
+            throw new daml_lf_semantic_exception_js_1.DamlLfSemanticException(`could not resolve template '${templateId.templateName}' in module '${templateId.moduleName}'`);
+        }
+        return template;
+    }
+    static createTemplateKey(templateId) {
+        return `${templateId.packageId}::${templateId.moduleName}::${templateId.templateName}`;
+    }
+}
+exports.DamlLfCompilation = DamlLfCompilation;

package/dist/cjs/daml-lf/daml-lf-package-loader.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfPackageLoader = exports.DamlLfPackageLoadResult = void 0;
+const archive_payload_decoder_js_1 = require("./decoding/archive-payload-decoder.js");
+const package_decoder_registry_js_1 = require("./decoding/package-decoder-registry.js");
+const lf_2_model_mapper_js_1 = require("./model/lf-2-model-mapper.js");
+class DamlLfPackageLoadResult {
+    packageId;
+    languageVersion;
+    rawPackage;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.languageVersion = init.languageVersion;
+        this.rawPackage = init.rawPackage;
+    }
+}
+exports.DamlLfPackageLoadResult = DamlLfPackageLoadResult;
+class DamlLfPackageLoader {
+    packageDecoderRegistry;
+    constructor(packageDecoderRegistry = new package_decoder_registry_js_1.PackageDecoderRegistry()) {
+        this.packageDecoderRegistry = packageDecoderRegistry;
+        void this.packageDecoderRegistry;
+    }
+    loadRawPackageOrThrow(archiveBytes) {
+        const envelope = archive_payload_decoder_js_1.ArchivePayloadDecoder.decodeArchiveOrThrow(archiveBytes);
+        const rawPackage = this.packageDecoderRegistry.decodePackageOrThrow(envelope.packagePayload, envelope.languageVersion);
+        return new DamlLfPackageLoadResult({
+            packageId: envelope.packageId,
+            languageVersion: envelope.languageVersion,
+            rawPackage,
+        });
+    }
+    loadPackageOrThrow(archiveBytes) {
+        const result = this.loadRawPackageOrThrow(archiveBytes);
+        return lf_2_model_mapper_js_1.Lf2ModelMapper.mapPackage(result.packageId, result.rawPackage, result.languageVersion);
+    }
+}
+exports.DamlLfPackageLoader = DamlLfPackageLoader;

package/dist/cjs/daml-lf/daml-lf-workspace.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfWorkspace = void 0;
+class DamlLfWorkspace {
+    packages;
+    constructor(packages) {
+        this.packages = packages;
+    }
+}
+exports.DamlLfWorkspace = DamlLfWorkspace;

package/dist/cjs/daml-lf/decoding/archive-payload-decoder.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchivePayloadDecoder = void 0;
+const daml_lf_js_1 = require("../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf.js");
+const daml_lf_decode_exception_js_1 = require("../errors/daml-lf-decode.exception.js");
+const daml_lf_version_not_supported_exception_js_1 = require("../errors/daml-lf-version-not-supported.exception.js");
+const archive_payload_envelope_js_1 = require("./archive-payload-envelope.js");
+const daml_lf_language_version_js_1 = require("./daml-lf-language-version.js");
+class ArchivePayloadDecoder {
+    static decodeArchiveOrThrow(archiveBytes) {
+        try {
+            const archive = daml_lf_js_1.Archive.fromBinary(archiveBytes);
+            const payload = daml_lf_js_1.ArchivePayload.fromBinary(archive.payload);
+            const languageVersion = ArchivePayloadDecoder.getLanguageVersionOrThrow(payload);
+            const packagePayload = ArchivePayloadDecoder.getPackagePayloadOrThrow(payload);
+            return new archive_payload_envelope_js_1.ArchivePayloadEnvelope({
+                packageId: archive.hash,
+                languageVersion,
+                packagePayload,
+            });
+        }
+        catch (error) {
+            if (error instanceof daml_lf_version_not_supported_exception_js_1.DamlLfVersionNotSupportedException ||
+                error instanceof daml_lf_decode_exception_js_1.DamlLfDecodeException) {
+                throw error;
+            }
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException(error instanceof Error
+                ? error.message
+                : "failed to decode daml lf archive payload");
+        }
+    }
+    static getLanguageVersionOrThrow(payload) {
+        switch (payload.sum.oneofKind) {
+            case "damlLf2":
+                return new daml_lf_language_version_js_1.DamlLfLanguageVersion({
+                    major: 2,
+                    minor: payload.minor,
+                    patch: payload.patch,
+                });
+            case "damlLf1":
+                return new daml_lf_language_version_js_1.DamlLfLanguageVersion({
+                    major: 1,
+                    minor: payload.minor,
+                    patch: payload.patch,
+                });
+            default:
+                throw new daml_lf_version_not_supported_exception_js_1.DamlLfVersionNotSupportedException("daml lf archive payload does not declare a supported package kind");
+        }
+    }
+    static getPackagePayloadOrThrow(payload) {
+        switch (payload.sum.oneofKind) {
+            case "damlLf2":
+                return payload.sum.damlLf2;
+            case "damlLf1":
+                throw new daml_lf_version_not_supported_exception_js_1.DamlLfVersionNotSupportedException("daml lf 1.x is not supported yet");
+            default:
+                throw new daml_lf_version_not_supported_exception_js_1.DamlLfVersionNotSupportedException("daml lf archive payload does not contain a package body");
+        }
+    }
+}
+exports.ArchivePayloadDecoder = ArchivePayloadDecoder;

package/dist/cjs/daml-lf/decoding/archive-payload-envelope.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchivePayloadEnvelope = void 0;
+class ArchivePayloadEnvelope {
+    packageId;
+    languageVersion;
+    packagePayload;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.languageVersion = init.languageVersion;
+        this.packagePayload = init.packagePayload;
+    }
+}
+exports.ArchivePayloadEnvelope = ArchivePayloadEnvelope;

package/dist/cjs/daml-lf/decoding/daml-lf-language-version.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlLfLanguageVersion = void 0;
+class DamlLfLanguageVersion {
+    major;
+    minor;
+    patch;
+    constructor(init) {
+        this.major = init.major;
+        this.minor = init.minor;
+        this.patch = init.patch;
+    }
+    toString() {
+        return `${this.major}.${this.minor}`;
+    }
+}
+exports.DamlLfLanguageVersion = DamlLfLanguageVersion;

package/dist/cjs/daml-lf/decoding/lf-2-package-decoder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lf2PackageDecoder = void 0;
+const daml_lf2_js_1 = require("../../transports/grpc/generated/canton/com/digitalasset/daml/lf/archive/daml_lf2.js");
+const daml_lf_decode_exception_js_1 = require("../errors/daml-lf-decode.exception.js");
+class Lf2PackageDecoder {
+    canDecode(languageVersion) {
+        return languageVersion.major === 2;
+    }
+    decodePackageOrThrow(packageBytes) {
+        try {
+            return daml_lf2_js_1.Package.fromBinary(packageBytes);
+        }
+        catch (error) {
+            throw new daml_lf_decode_exception_js_1.DamlLfDecodeException(error instanceof Error
+                ? error.message
+                : "failed to decode daml lf 2.x package");
+        }
+    }
+}
+exports.Lf2PackageDecoder = Lf2PackageDecoder;

package/dist/cjs/daml-lf/decoding/package-decoder-registry.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageDecoderRegistry = void 0;
+const daml_lf_version_not_supported_exception_js_1 = require("../errors/daml-lf-version-not-supported.exception.js");
+const lf_2_package_decoder_js_1 = require("./lf-2-package-decoder.js");
+class PackageDecoderRegistry {
+    decoders;
+    constructor(decoders = [
+        new lf_2_package_decoder_js_1.Lf2PackageDecoder(),
+    ]) {
+        this.decoders = decoders;
+    }
+    decodePackageOrThrow(packageBytes, languageVersion) {
+        const decoder = this.decoders.find((candidate) => candidate.canDecode(languageVersion));
+        if (decoder === undefined) {
+            throw new daml_lf_version_not_supported_exception_js_1.DamlLfVersionNotSupportedException(`daml lf ${languageVersion.toString()} is not supported yet`);
+        }
+        return decoder.decodePackageOrThrow(packageBytes);
+    }
+}
+exports.PackageDecoderRegistry = PackageDecoderRegistry;

package/dist/cjs/daml-lf/decoding/package-decoder.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/daml-lf/errors/daml-lf-archive.exception.js

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

package/dist/cjs/daml-lf/errors/daml-lf-decode.exception.js

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

package/dist/cjs/daml-lf/errors/daml-lf-resolution.exception.js

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

package/dist/cjs/daml-lf/errors/daml-lf-semantic.exception.js

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

package/dist/cjs/daml-lf/errors/daml-lf-version-not-supported.exception.js

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

package/dist/cjs/daml-lf/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeConReference = exports.DamlLfSemanticModel = exports.ModuleReference = exports.DamlLfValueDefinition = exports.DamlLfType = exports.DamlLfTemplateId = exports.DamlLfTemplate = exports.DamlLfPackage = exports.DamlLfNodeKind = exports.DamlLfModule = exports.DamlLfField = exports.DamlLfExpression = exports.DamlLfDataType = exports.DamlLfChoiceParameter = exports.DamlLfChoice = exports.DamlLfBuiltinType = exports.DamlLfStepKind = exports.DamlLfRuntimeFrame = exports.DamlLfLexicalScope = exports.DamlLfInterpreterScaffold = exports.DamlLfEvaluator = exports.DamlLfBuiltinDispatch = exports.DamlLfLanguageVersion = exports.DarSourceFileEntry = exports.DarSourceBundleLoader = exports.DarSourceBundle = exports.DarArchiveLoader = exports.DarArchiveEntry = exports.DamlLfWorkspace = exports.DamlLfPackageLoadResult = exports.DamlLfPackageLoader = exports.DamlLfCompilation = exports.DamlLfVersionNotSupportedException = exports.DamlLfSemanticException = exports.DamlLfResolutionException = exports.DamlLfDecodeException = exports.DamlLfArchiveException = void 0;
+var daml_lf_archive_exception_js_1 = require("./errors/daml-lf-archive.exception.js");
+Object.defineProperty(exports, "DamlLfArchiveException", { enumerable: true, get: function () { return daml_lf_archive_exception_js_1.DamlLfArchiveException; } });
+var daml_lf_decode_exception_js_1 = require("./errors/daml-lf-decode.exception.js");
+Object.defineProperty(exports, "DamlLfDecodeException", { enumerable: true, get: function () { return daml_lf_decode_exception_js_1.DamlLfDecodeException; } });
+var daml_lf_resolution_exception_js_1 = require("./errors/daml-lf-resolution.exception.js");
+Object.defineProperty(exports, "DamlLfResolutionException", { enumerable: true, get: function () { return daml_lf_resolution_exception_js_1.DamlLfResolutionException; } });
+var daml_lf_semantic_exception_js_1 = require("./errors/daml-lf-semantic.exception.js");
+Object.defineProperty(exports, "DamlLfSemanticException", { enumerable: true, get: function () { return daml_lf_semantic_exception_js_1.DamlLfSemanticException; } });
+var daml_lf_version_not_supported_exception_js_1 = require("./errors/daml-lf-version-not-supported.exception.js");
+Object.defineProperty(exports, "DamlLfVersionNotSupportedException", { enumerable: true, get: function () { return daml_lf_version_not_supported_exception_js_1.DamlLfVersionNotSupportedException; } });
+var daml_lf_compilation_js_1 = require("./daml-lf-compilation.js");
+Object.defineProperty(exports, "DamlLfCompilation", { enumerable: true, get: function () { return daml_lf_compilation_js_1.DamlLfCompilation; } });
+var daml_lf_package_loader_js_1 = require("./daml-lf-package-loader.js");
+Object.defineProperty(exports, "DamlLfPackageLoader", { enumerable: true, get: function () { return daml_lf_package_loader_js_1.DamlLfPackageLoader; } });
+Object.defineProperty(exports, "DamlLfPackageLoadResult", { enumerable: true, get: function () { return daml_lf_package_loader_js_1.DamlLfPackageLoadResult; } });
+var daml_lf_workspace_js_1 = require("./daml-lf-workspace.js");
+Object.defineProperty(exports, "DamlLfWorkspace", { enumerable: true, get: function () { return daml_lf_workspace_js_1.DamlLfWorkspace; } });
+var dar_archive_entry_js_1 = require("./container/dar-archive-entry.js");
+Object.defineProperty(exports, "DarArchiveEntry", { enumerable: true, get: function () { return dar_archive_entry_js_1.DarArchiveEntry; } });
+var dar_archive_loader_js_1 = require("./container/dar-archive-loader.js");
+Object.defineProperty(exports, "DarArchiveLoader", { enumerable: true, get: function () { return dar_archive_loader_js_1.DarArchiveLoader; } });
+var dar_source_bundle_js_1 = require("./container/dar-source-bundle.js");
+Object.defineProperty(exports, "DarSourceBundle", { enumerable: true, get: function () { return dar_source_bundle_js_1.DarSourceBundle; } });
+var dar_source_bundle_loader_js_1 = require("./container/dar-source-bundle-loader.js");
+Object.defineProperty(exports, "DarSourceBundleLoader", { enumerable: true, get: function () { return dar_source_bundle_loader_js_1.DarSourceBundleLoader; } });
+var dar_source_file_entry_js_1 = require("./container/dar-source-file-entry.js");
+Object.defineProperty(exports, "DarSourceFileEntry", { enumerable: true, get: function () { return dar_source_file_entry_js_1.DarSourceFileEntry; } });
+var daml_lf_language_version_js_1 = require("./decoding/daml-lf-language-version.js");
+Object.defineProperty(exports, "DamlLfLanguageVersion", { enumerable: true, get: function () { return daml_lf_language_version_js_1.DamlLfLanguageVersion; } });
+var daml_lf_builtin_dispatch_js_1 = require("./interpreter/daml-lf-builtin-dispatch.js");
+Object.defineProperty(exports, "DamlLfBuiltinDispatch", { enumerable: true, get: function () { return daml_lf_builtin_dispatch_js_1.DamlLfBuiltinDispatch; } });
+var daml_lf_evaluator_js_1 = require("./interpreter/daml-lf-evaluator.js");
+Object.defineProperty(exports, "DamlLfEvaluator", { enumerable: true, get: function () { return daml_lf_evaluator_js_1.DamlLfEvaluator; } });
+var daml_lf_interpreter_scaffold_js_1 = require("./interpreter/daml-lf-interpreter-scaffold.js");
+Object.defineProperty(exports, "DamlLfInterpreterScaffold", { enumerable: true, get: function () { return daml_lf_interpreter_scaffold_js_1.DamlLfInterpreterScaffold; } });
+var daml_lf_lexical_scope_js_1 = require("./interpreter/daml-lf-lexical-scope.js");
+Object.defineProperty(exports, "DamlLfLexicalScope", { enumerable: true, get: function () { return daml_lf_lexical_scope_js_1.DamlLfLexicalScope; } });
+var daml_lf_runtime_frame_js_1 = require("./interpreter/daml-lf-runtime-frame.js");
+Object.defineProperty(exports, "DamlLfRuntimeFrame", { enumerable: true, get: function () { return daml_lf_runtime_frame_js_1.DamlLfRuntimeFrame; } });
+var daml_lf_step_kind_js_1 = require("./interpreter/daml-lf-step-kind.js");
+Object.defineProperty(exports, "DamlLfStepKind", { enumerable: true, get: function () { return daml_lf_step_kind_js_1.DamlLfStepKind; } });
+var daml_lf_builtin_type_js_1 = require("./model/daml-lf-builtin-type.js");
+Object.defineProperty(exports, "DamlLfBuiltinType", { enumerable: true, get: function () { return daml_lf_builtin_type_js_1.DamlLfBuiltinType; } });
+var daml_lf_choice_js_1 = require("./model/daml-lf-choice.js");
+Object.defineProperty(exports, "DamlLfChoice", { enumerable: true, get: function () { return daml_lf_choice_js_1.DamlLfChoice; } });
+var daml_lf_choice_parameter_js_1 = require("./model/daml-lf-choice-parameter.js");
+Object.defineProperty(exports, "DamlLfChoiceParameter", { enumerable: true, get: function () { return daml_lf_choice_parameter_js_1.DamlLfChoiceParameter; } });
+var daml_lf_data_type_js_1 = require("./model/daml-lf-data-type.js");
+Object.defineProperty(exports, "DamlLfDataType", { enumerable: true, get: function () { return daml_lf_data_type_js_1.DamlLfDataType; } });
+var daml_lf_expression_js_1 = require("./model/daml-lf-expression.js");
+Object.defineProperty(exports, "DamlLfExpression", { enumerable: true, get: function () { return daml_lf_expression_js_1.DamlLfExpression; } });
+var daml_lf_field_js_1 = require("./model/daml-lf-field.js");
+Object.defineProperty(exports, "DamlLfField", { enumerable: true, get: function () { return daml_lf_field_js_1.DamlLfField; } });
+var daml_lf_module_js_1 = require("./model/daml-lf-module.js");
+Object.defineProperty(exports, "DamlLfModule", { enumerable: true, get: function () { return daml_lf_module_js_1.DamlLfModule; } });
+var daml_lf_node_kind_js_1 = require("./model/daml-lf-node-kind.js");
+Object.defineProperty(exports, "DamlLfNodeKind", { enumerable: true, get: function () { return daml_lf_node_kind_js_1.DamlLfNodeKind; } });
+var daml_lf_package_js_1 = require("./model/daml-lf-package.js");
+Object.defineProperty(exports, "DamlLfPackage", { enumerable: true, get: function () { return daml_lf_package_js_1.DamlLfPackage; } });
+var daml_lf_template_js_1 = require("./model/daml-lf-template.js");
+Object.defineProperty(exports, "DamlLfTemplate", { enumerable: true, get: function () { return daml_lf_template_js_1.DamlLfTemplate; } });
+var daml_lf_template_id_js_1 = require("./model/daml-lf-template-id.js");
+Object.defineProperty(exports, "DamlLfTemplateId", { enumerable: true, get: function () { return daml_lf_template_id_js_1.DamlLfTemplateId; } });
+var daml_lf_type_js_1 = require("./model/daml-lf-type.js");
+Object.defineProperty(exports, "DamlLfType", { enumerable: true, get: function () { return daml_lf_type_js_1.DamlLfType; } });
+var daml_lf_value_definition_js_1 = require("./model/daml-lf-value-definition.js");
+Object.defineProperty(exports, "DamlLfValueDefinition", { enumerable: true, get: function () { return daml_lf_value_definition_js_1.DamlLfValueDefinition; } });
+var module_reference_js_1 = require("./model/module-reference.js");
+Object.defineProperty(exports, "ModuleReference", { enumerable: true, get: function () { return module_reference_js_1.ModuleReference; } });
+var daml_lf_semantic_model_js_1 = require("./semantics/daml-lf-semantic-model.js");
+Object.defineProperty(exports, "DamlLfSemanticModel", { enumerable: true, get: function () { return daml_lf_semantic_model_js_1.DamlLfSemanticModel; } });
+var type_con_reference_js_1 = require("./model/type-con-reference.js");
+Object.defineProperty(exports, "TypeConReference", { enumerable: true, get: function () { return type_con_reference_js_1.TypeConReference; } });