@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/core/types/topology/topology-public-key.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologySigningKeysWithThreshold = exports.TopologyPublicKey = exports.TopologyEncryptionPublicKey = exports.TopologySigningPublicKey = void 0;
+class TopologySigningPublicKey {
+    fingerprint;
+    format;
+    publicKey;
+    scheme;
+    usage;
+    keySpec;
+    constructor(init = {}) {
+        this.fingerprint = init.fingerprint;
+        this.format = init.format;
+        this.publicKey = new Uint8Array(init.publicKey ?? []);
+        this.scheme = init.scheme;
+        this.usage = [...(init.usage ?? [])];
+        this.keySpec = init.keySpec;
+    }
+}
+exports.TopologySigningPublicKey = TopologySigningPublicKey;
+class TopologyEncryptionPublicKey {
+    fingerprint;
+    format;
+    publicKey;
+    scheme;
+    keySpec;
+    constructor(init = {}) {
+        this.fingerprint = init.fingerprint;
+        this.format = init.format;
+        this.publicKey = new Uint8Array(init.publicKey ?? []);
+        this.scheme = init.scheme;
+        this.keySpec = init.keySpec;
+    }
+}
+exports.TopologyEncryptionPublicKey = TopologyEncryptionPublicKey;
+class TopologyPublicKey {
+    signingPublicKey;
+    encryptionPublicKey;
+    constructor(init = {}) {
+        this.signingPublicKey = init.signingPublicKey;
+        this.encryptionPublicKey = init.encryptionPublicKey;
+    }
+}
+exports.TopologyPublicKey = TopologyPublicKey;
+class TopologySigningKeysWithThreshold {
+    threshold;
+    keys;
+    constructor(init = {}) {
+        this.threshold = init.threshold ?? 0;
+        this.keys = [...(init.keys ?? [])];
+    }
+}
+exports.TopologySigningKeysWithThreshold = TopologySigningKeysWithThreshold;

package/dist/cjs/core/types/topology/topology-signature-delegation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologySignatureDelegation = void 0;
+class TopologySignatureDelegation {
+    sessionKey;
+    sessionKeySpec;
+    validityPeriodFromInclusive;
+    validityPeriodDurationSeconds;
+    format;
+    signature;
+    signingAlgorithmSpec;
+    constructor(init = {}) {
+        this.sessionKey = new Uint8Array(init.sessionKey ?? []);
+        this.sessionKeySpec = init.sessionKeySpec;
+        this.validityPeriodFromInclusive =
+            init.validityPeriodFromInclusive ?? "0";
+        this.validityPeriodDurationSeconds =
+            init.validityPeriodDurationSeconds ?? 0;
+        this.format = init.format;
+        this.signature = new Uint8Array(init.signature ?? []);
+        this.signingAlgorithmSpec = init.signingAlgorithmSpec;
+    }
+}
+exports.TopologySignatureDelegation = TopologySignatureDelegation;

package/dist/cjs/core/types/topology/topology-signature-format.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologySignatureFormat = void 0;
+var TopologySignatureFormat;
+(function (TopologySignatureFormat) {
+    TopologySignatureFormat["ed25519"] = "ed25519";
+    TopologySignatureFormat["ecDsaSha256"] = "ecDsaSha256";
+})(TopologySignatureFormat || (exports.TopologySignatureFormat = TopologySignatureFormat = {}));

package/dist/cjs/core/types/topology/topology-store-id.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyStoreId = exports.TopologyStoreTemporary = exports.TopologyStoreSynchronizer = exports.TopologyStoreAuthorized = exports.TopologyStoreKind = void 0;
+var TopologyStoreKind;
+(function (TopologyStoreKind) {
+    TopologyStoreKind["authorized"] = "authorized";
+    TopologyStoreKind["synchronizer"] = "synchronizer";
+    TopologyStoreKind["temporary"] = "temporary";
+})(TopologyStoreKind || (exports.TopologyStoreKind = TopologyStoreKind = {}));
+class TopologyStoreAuthorized {
+    constructor(_init = {}) {
+        void _init;
+    }
+}
+exports.TopologyStoreAuthorized = TopologyStoreAuthorized;
+class TopologyStoreSynchronizer {
+    id;
+    physicalId;
+    constructor(init = {}) {
+        this.id = init.id;
+        this.physicalId = init.physicalId;
+    }
+}
+exports.TopologyStoreSynchronizer = TopologyStoreSynchronizer;
+class TopologyStoreTemporary {
+    name;
+    constructor(init) {
+        this.name = init.name;
+    }
+}
+exports.TopologyStoreTemporary = TopologyStoreTemporary;
+class TopologyStoreId {
+    kind;
+    authorized;
+    synchronizer;
+    temporary;
+    constructor(init) {
+        this.kind = init.kind;
+        this.authorized = init.authorized;
+        this.synchronizer = init.synchronizer;
+        this.temporary = init.temporary;
+    }
+}
+exports.TopologyStoreId = TopologyStoreId;

package/dist/cjs/core/types/topology/topology-transaction-signature.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyTransactionSignature = void 0;
+class TopologyTransactionSignature {
+    format;
+    signature;
+    signedByFingerprint;
+    signingAlgorithmSpec;
+    signatureDelegation;
+    constructor(init = {}) {
+        this.format = init.format;
+        this.signature = new Uint8Array(init.signature ?? []);
+        this.signedByFingerprint = init.signedByFingerprint ?? "";
+        this.signingAlgorithmSpec = init.signingAlgorithmSpec;
+        this.signatureDelegation = init.signatureDelegation;
+    }
+}
+exports.TopologyTransactionSignature = TopologyTransactionSignature;

package/dist/cjs/core/types/topology/topology-transactions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyTransactions = exports.TopologyTransactionItem = void 0;
+class TopologyTransactionItem {
+    sequencedAt;
+    validFrom;
+    validUntil;
+    transaction;
+    rejectionReason;
+    constructor(init = {}) {
+        this.sequencedAt = init.sequencedAt;
+        this.validFrom = init.validFrom;
+        this.validUntil = init.validUntil;
+        this.transaction = new Uint8Array(init.transaction ?? []);
+        this.rejectionReason = init.rejectionReason;
+    }
+}
+exports.TopologyTransactionItem = TopologyTransactionItem;
+class TopologyTransactions {
+    items;
+    constructor(init = {}) {
+        this.items = [...(init.items ?? [])];
+    }
+}
+exports.TopologyTransactions = TopologyTransactions;

package/dist/cjs/core/types/topology/vetted-package.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyVettedPackage = void 0;
+class TopologyVettedPackage {
+    packageId;
+    validFromInclusive;
+    validUntilExclusive;
+    packageName;
+    packageVersion;
+    constructor(init) {
+        this.packageId = init.packageId;
+        this.validFromInclusive = init.validFromInclusive;
+        this.validUntilExclusive = init.validUntilExclusive;
+        this.packageName = init.packageName;
+        this.packageVersion = init.packageVersion;
+    }
+}
+exports.TopologyVettedPackage = TopologyVettedPackage;

package/dist/cjs/core/types/topology/vetted-packages.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyVettedPackages = void 0;
+class TopologyVettedPackages {
+    packages;
+    packageIds;
+    participantUid;
+    participantId;
+    synchronizerId;
+    topologySerial;
+    constructor(init = {}) {
+        this.packages = [...(init.packages ?? [])];
+        this.packageIds = [...(init.packageIds ?? [])];
+        this.participantUid = init.participantUid ?? init.participantId ?? "";
+        this.participantId = init.participantId ?? init.participantUid ?? "";
+        this.synchronizerId = init.synchronizerId;
+        this.topologySerial = init.topologySerial;
+    }
+}
+exports.TopologyVettedPackages = TopologyVettedPackages;

package/dist/cjs/core/types/topology-state-filter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologyStateFilter = void 0;
+class TopologyStateFilter {
+    participantIds;
+    synchronizerIds;
+    constructor(init = {}) {
+        this.participantIds = [...(init.participantIds ?? [])];
+        this.synchronizerIds = [...(init.synchronizerIds ?? [])];
+    }
+}
+exports.TopologyStateFilter = TopologyStateFilter;

package/dist/cjs/core/types/transport-kind.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportKind = void 0;
+var TransportKind;
+(function (TransportKind) {
+    TransportKind["grpc"] = "grpc";
+    TransportKind["json"] = "json";
+})(TransportKind || (exports.TransportKind = TransportKind = {}));

package/dist/cjs/core/types/user-right-kind.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRightKind = void 0;
+var UserRightKind;
+(function (UserRightKind) {
+    UserRightKind["canActAs"] = "canActAs";
+    UserRightKind["canReadAs"] = "canReadAs";
+    UserRightKind["canActAsAnyParty"] = "canActAsAnyParty";
+    UserRightKind["canExecuteAs"] = "canExecuteAs";
+    UserRightKind["canExecuteAsAnyParty"] = "canExecuteAsAnyParty";
+    UserRightKind["canReadAsAnyParty"] = "canReadAsAnyParty";
+    UserRightKind["identityProviderAdmin"] = "identityProviderAdmin";
+    UserRightKind["participantAdmin"] = "participantAdmin";
+})(UserRightKind || (exports.UserRightKind = UserRightKind = {}));

package/dist/cjs/core/types/vetted-package.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VettedPackage = void 0;
+var vetted_package_js_1 = require("./topology/vetted-package.js");
+Object.defineProperty(exports, "VettedPackage", { enumerable: true, get: function () { return vetted_package_js_1.TopologyVettedPackage; } });

package/dist/cjs/core/types/vetted-packages.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VettedPackages = void 0;
+var vetted_packages_js_1 = require("./topology/vetted-packages.js");
+Object.defineProperty(exports, "VettedPackages", { enumerable: true, get: function () { return vetted_packages_js_1.TopologyVettedPackages; } });

package/dist/cjs/core/types/wait-commitments-setup.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitCommitmentsSetup = void 0;
+class WaitCommitmentsSetup {
+    counterParticipantUid;
+    synchronizerIds;
+    constructor(init) {
+        this.counterParticipantUid = init.counterParticipantUid;
+        this.synchronizerIds = [...init.synchronizerIds];
+    }
+}
+exports.WaitCommitmentsSetup = WaitCommitmentsSetup;

package/dist/cjs/daml-interface/analysis/analyzed-choice.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzedChoice = void 0;
+class AnalyzedChoice {
+    name;
+    methodName;
+    parameterName;
+    parameterType;
+    returnType;
+    constructor(init) {
+        this.name = init.name;
+        this.methodName = init.methodName;
+        this.parameterName = init.parameterName;
+        this.parameterType = init.parameterType;
+        this.returnType = init.returnType;
+    }
+}
+exports.AnalyzedChoice = AnalyzedChoice;

package/dist/cjs/daml-interface/analysis/analyzed-daml-type-definition.js

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

package/dist/cjs/daml-interface/analysis/analyzed-daml-type.js

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

package/dist/cjs/daml-interface/analysis/analyzed-template.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzedTemplate = exports.AnalyzedTemplateField = void 0;
+class AnalyzedTemplateField {
+    name;
+    propertyName;
+    type;
+    constructor(init) {
+        this.name = init.name;
+        this.propertyName = init.propertyName;
+        this.type = init.type;
+    }
+}
+exports.AnalyzedTemplateField = AnalyzedTemplateField;
+class AnalyzedTemplate {
+    templateId;
+    className;
+    fileName;
+    createFields;
+    choices;
+    constructor(init) {
+        this.templateId = init.templateId;
+        this.className = init.className;
+        this.fileName = init.fileName;
+        this.createFields = init.createFields;
+        this.choices = init.choices;
+    }
+}
+exports.AnalyzedTemplate = AnalyzedTemplate;

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

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceAnalyzer = exports.DamlInterfaceAnalysisResult = void 0;
+const daml_lf_builtin_type_js_1 = require("../../daml-lf/model/daml-lf-builtin-type.js");
+const type_con_reference_js_1 = require("../../daml-lf/model/type-con-reference.js");
+const daml_interface_unsupported_shape_exception_js_1 = require("../errors/daml-interface-unsupported-shape.exception.js");
+const analyzed_choice_js_1 = require("./analyzed-choice.js");
+const analyzed_template_js_1 = require("./analyzed-template.js");
+class DamlInterfaceAnalysisResult {
+    templates;
+    typeDefinitions;
+    packageMetadata;
+    constructor(init) {
+        this.templates = Object.freeze([...init.templates]);
+        this.typeDefinitions = Object.freeze([...init.typeDefinitions]);
+        this.packageMetadata = new Map(init.packageMetadata);
+    }
+}
+exports.DamlInterfaceAnalysisResult = DamlInterfaceAnalysisResult;
+class DamlInterfaceAnalyzer {
+    /** Analyzes compiled DAML-LF templates into generator-facing metadata. */
+    analyzeOrThrow(compilation) {
+        const semanticModel = compilation.createSemanticModel();
+        const typeBuilder = new AnalyzedDamlTypeBuilder(semanticModel, (value) => this.toCamelCase(value));
+        const templates = semanticModel
+            .getTemplates()
+            .map((item) => this.analyzeTemplateOrThrow(item, typeBuilder));
+        return new DamlInterfaceAnalysisResult({
+            templates,
+            typeDefinitions: typeBuilder.getTypeDefinitions(),
+            packageMetadata: new Map(compilation.getPackages().map((pkg) => [
+                pkg.packageId,
+                {
+                    packageName: pkg.packageName,
+                    packageVersion: pkg.packageVersion,
+                },
+            ])),
+        });
+    }
+    analyzeTemplateOrThrow(template, typeBuilder) {
+        return new analyzed_template_js_1.AnalyzedTemplate({
+            templateId: template.templateId,
+            className: this.toPascalCase(template.name),
+            fileName: `${this.toKebabCase(template.name)}.ts`,
+            createFields: template.fields.map((item) => this.analyzeTemplateFieldOrThrow(item, typeBuilder)),
+            choices: template.choices.map((item) => this.analyzeChoiceOrThrow(item, typeBuilder)),
+        });
+    }
+    analyzeTemplateFieldOrThrow(field, typeBuilder) {
+        const type = typeBuilder.buildOrThrow(field.type, `template field '${field.name}'`);
+        return new analyzed_template_js_1.AnalyzedTemplateField({
+            name: field.name,
+            propertyName: this.toCamelCase(field.name),
+            type,
+        });
+    }
+    analyzeChoiceOrThrow(choice, typeBuilder) {
+        const parameterType = typeBuilder.buildOrThrow(choice.parameter.type, `choice parameter '${choice.parameter.name}'`);
+        const returnType = typeBuilder.buildOrThrow(choice.returnType, `choice return type '${choice.name}'`);
+        return new analyzed_choice_js_1.AnalyzedChoice({
+            name: choice.name,
+            methodName: `exercise${this.toPascalCase(choice.name)}`,
+            parameterName: this.toCamelCase(choice.parameter.name),
+            parameterType,
+            returnType,
+        });
+    }
+    toCamelCase(value) {
+        const pascalCase = this.toPascalCase(value);
+        if (pascalCase.length === 0) {
+            throw new daml_interface_unsupported_shape_exception_js_1.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 daml_interface_unsupported_shape_exception_js_1.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();
+    }
+}
+exports.DamlInterfaceAnalyzer = DamlInterfaceAnalyzer;
+class AnalyzedDamlTypeBuilder {
+    semanticModel;
+    toCamelCase;
+    definitionKeys = [];
+    canonicalIdentities = new Map();
+    definitions = new Map();
+    constructor(semanticModel, toCamelCase) {
+        this.semanticModel = semanticModel;
+        this.toCamelCase = toCamelCase;
+    }
+    buildOrThrow(type, context, typeParameters = new Map()) {
+        if (type.diagnosticForall !== undefined) {
+            throw this.unsupported(context, "retained forall types are not supported");
+        }
+        else if (type.typeVariable !== undefined) {
+            if (type.typeVariable.name === undefined) {
+                throw this.unsupported(context, `type variable '${this.getTypeVariableName(type.typeVariable)}' requires a resolved name`);
+            }
+            else if (type.typeArguments.length !== 0) {
+                throw this.unsupported(context, "applied type variables are not supported");
+            }
+            const parameter = typeParameters.get(type.typeVariable.internedStringIndex);
+            if (parameter === undefined) {
+                throw this.unsupported(context, `unbound type variable '${this.getTypeVariableName(type.typeVariable)}'`);
+            }
+            return Object.freeze({
+                kind: "typeVariable",
+                ...(parameter.name === undefined ? {} : { name: parameter.name }),
+                internedStringIndex: parameter.internedStringIndex,
+            });
+        }
+        else if (type.typeConReference !== undefined) {
+            if (type.builtinType !== daml_lf_builtin_type_js_1.DamlLfBuiltinType.unknown) {
+                throw this.unsupported(context, "a type constructor cannot also be a builtin type");
+            }
+            return this.buildNamedReferenceOrThrow(type.typeConReference, type.typeArguments, context, typeParameters);
+        }
+        switch (type.builtinType) {
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.unit:
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.bool:
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.int64:
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.date:
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.timestamp:
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.party:
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.text:
+                this.assertArgumentCountOrThrow(type, 0, context);
+                return Object.freeze({
+                    kind: "primitive",
+                    builtinType: type.builtinType,
+                    ...(type.numericScale === undefined
+                        ? {}
+                        : { numericScale: type.numericScale }),
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.numeric:
+                this.assertArgumentCountOrThrow(type, 0, context);
+                if (type.numericScale === undefined ||
+                    !Number.isInteger(type.numericScale) ||
+                    type.numericScale < 0 ||
+                    type.numericScale > 37) {
+                    throw this.unsupported(context, "numeric values require an integer scale from 0 through 37");
+                }
+                return Object.freeze({
+                    kind: "primitive",
+                    builtinType: type.builtinType,
+                    numericScale: type.numericScale,
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.contractId:
+                this.assertArgumentCountOrThrow(type, 1, context);
+                return Object.freeze({
+                    kind: "contractId",
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.optional:
+                return Object.freeze({
+                    kind: "optional",
+                    element: this.buildUnaryArgumentOrThrow(type, context, typeParameters),
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.list:
+                return Object.freeze({
+                    kind: "list",
+                    element: this.buildUnaryArgumentOrThrow(type, context, typeParameters),
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.textMap:
+                return Object.freeze({
+                    kind: "textMap",
+                    value: this.buildUnaryArgumentOrThrow(type, context, typeParameters),
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.genMap:
+                this.assertArgumentCountOrThrow(type, 2, context);
+                return Object.freeze({
+                    kind: "genMap",
+                    key: this.buildOrThrow(type.typeArguments[0], context, typeParameters),
+                    value: this.buildOrThrow(type.typeArguments[1], context, typeParameters),
+                });
+            case daml_lf_builtin_type_js_1.DamlLfBuiltinType.unknown:
+                throw this.unsupported(context, "the type is not serializable");
+        }
+    }
+    getTypeDefinitions() {
+        return Object.freeze(this.definitionKeys.map((key) => {
+            const definition = this.definitions.get(key);
+            if (definition === undefined) {
+                throw new daml_interface_unsupported_shape_exception_js_1.DamlInterfaceUnsupportedShapeException(`could not finish resolving named DAML type '${key}'`);
+            }
+            return definition;
+        }));
+    }
+    buildUnaryArgumentOrThrow(type, context, typeParameters) {
+        this.assertArgumentCountOrThrow(type, 1, context);
+        return this.buildOrThrow(type.typeArguments[0], context, typeParameters);
+    }
+    buildNamedReferenceOrThrow(reference, typeArguments, context, typeParameters) {
+        const key = this.getDefinitionKey(reference);
+        const identity = this.getCanonicalIdentity(reference, key);
+        const dataType = this.getDataTypeOrThrow(reference, context);
+        this.assertSupportedDataTypeParametersOrThrow(dataType, context);
+        this.assertNamedArgumentCountOrThrow(typeArguments, dataType, context);
+        const analyzedTypeArguments = Object.freeze(typeArguments.map((argument) => this.buildOrThrow(argument, context, typeParameters)));
+        if (!this.definitions.has(key)) {
+            this.definitionKeys.push(key);
+            this.definitions.set(key, undefined);
+            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
+        }
+        return Object.freeze({
+            kind: "namedReference",
+            identity,
+            typeArguments: analyzedTypeArguments,
+        });
+    }
+    buildNamedDefinitionOrThrow(reference, identity, dataType) {
+        const typeParameters = this.createTypeParameterScope(dataType.typeParameters);
+        if (dataType.definition.kind === "record") {
+            return Object.freeze({
+                identity,
+                typeParameters: Object.freeze([...dataType.typeParameters]),
+                kind: "record",
+                fields: Object.freeze(dataType.definition.fields.map((field) => Object.freeze({
+                    damlLabel: field.name,
+                    propertyName: this.toCamelCase(field.name),
+                    type: this.buildOrThrow(field.type, `field '${field.name}' of record '${reference.name}'`, typeParameters),
+                }))),
+            });
+        }
+        else if (dataType.definition.kind === "variant") {
+            return Object.freeze({
+                identity,
+                typeParameters: Object.freeze([...dataType.typeParameters]),
+                kind: "variant",
+                constructors: Object.freeze(dataType.definition.constructors.map((constructor) => Object.freeze({
+                    constructor: constructor.name,
+                    payload: this.buildOrThrow(constructor.type, `constructor '${constructor.name}' of variant '${reference.name}'`, typeParameters),
+                }))),
+            });
+        }
+        return Object.freeze({
+            identity,
+            kind: "enum",
+            constructors: Object.freeze([...dataType.definition.constructors]),
+        });
+    }
+    assertArgumentCountOrThrow(type, expectedCount, context) {
+        if (type.typeArguments.length !== expectedCount) {
+            throw this.unsupported(context, `builtin '${type.builtinType}' requires ${expectedCount} type argument${expectedCount === 1 ? "" : "s"}`);
+        }
+    }
+    getDataTypeOrThrow(reference, context) {
+        try {
+            return this.semanticModel.getDataTypeOrThrow(reference);
+        }
+        catch {
+            throw this.unsupported(context, `could not resolve named type '${reference.packageId}:${reference.moduleName}:${reference.name}'`);
+        }
+    }
+    assertSupportedDataTypeParametersOrThrow(dataType, context) {
+        if (dataType.definition.kind === "enum" &&
+            dataType.typeParameters.length !== 0) {
+            throw this.unsupported(context, "generic enums are not supported");
+        }
+        for (const parameter of dataType.typeParameters) {
+            if (parameter.name === undefined) {
+                throw this.unsupported(context, `type parameter '${this.getTypeParameterName(parameter)}' requires a resolved name`);
+            }
+            else if (parameter.kind.kind !== "star") {
+                throw this.unsupported(context, `type parameter '${this.getTypeParameterName(parameter)}' must have kind '*'`);
+            }
+        }
+    }
+    assertNamedArgumentCountOrThrow(typeArguments, dataType, context) {
+        const expectedCount = dataType.typeParameters.length;
+        if (typeArguments.length !== expectedCount) {
+            throw this.unsupported(context, `named type '${dataType.name}' requires ${expectedCount} type argument${expectedCount === 1 ? "" : "s"}`);
+        }
+    }
+    createTypeParameterScope(parameters) {
+        return new Map(parameters.map((parameter) => [
+            parameter.internedStringIndex,
+            parameter,
+        ]));
+    }
+    getTypeVariableName(typeVariable) {
+        return typeVariable.name ?? `#${typeVariable.internedStringIndex}`;
+    }
+    getTypeParameterName(parameter) {
+        return parameter.name ?? `#${parameter.internedStringIndex}`;
+    }
+    getDefinitionKey(reference) {
+        return `${reference.packageId}::${reference.moduleName}::${reference.name}`;
+    }
+    getCanonicalIdentity(reference, key) {
+        let identity = this.canonicalIdentities.get(key);
+        if (identity === undefined) {
+            identity = Object.freeze(new type_con_reference_js_1.TypeConReference({
+                packageId: reference.packageId,
+                moduleName: reference.moduleName,
+                name: reference.name,
+            }));
+            this.canonicalIdentities.set(key, identity);
+        }
+        return identity;
+    }
+    unsupported(context, reason) {
+        return new daml_interface_unsupported_shape_exception_js_1.DamlInterfaceUnsupportedShapeException(`${context} is not supported by the DAML interface generator: ${reason}`);
+    }
+}