@bifold/oca 1.0.0

package/build/types/branding/BrandingOverlay.js

@@ -0,0 +1,68 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _BrandingOverlay_background_image, _BrandingOverlay_background_image_slice, _BrandingOverlay_primary_background_color, _BrandingOverlay_secondary_background_color, _BrandingOverlay_primary_attribute, _BrandingOverlay_secondary_attribute, _BrandingOverlay_issued_date_attribute, _BrandingOverlay_expiry_date_attribute;
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("../../utils/color");
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+class BrandingOverlay extends BaseOverlay_1.default {
+    constructor(credentialDefinitionId, overlay) {
+        var _a;
+        super(overlay);
+        _BrandingOverlay_background_image.set(this, void 0);
+        _BrandingOverlay_background_image_slice.set(this, void 0);
+        _BrandingOverlay_primary_background_color.set(this, void 0);
+        _BrandingOverlay_secondary_background_color.set(this, void 0);
+        _BrandingOverlay_primary_attribute.set(this, void 0);
+        _BrandingOverlay_secondary_attribute.set(this, void 0);
+        _BrandingOverlay_issued_date_attribute.set(this, void 0);
+        _BrandingOverlay_expiry_date_attribute.set(this, void 0);
+        this.logo = overlay.logo;
+        __classPrivateFieldSet(this, _BrandingOverlay_background_image, overlay.background_image, "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_background_image_slice, overlay.background_image_slice, "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_primary_background_color, (_a = overlay.primary_background_color) !== null && _a !== void 0 ? _a : (0, color_1.generateColor)(credentialDefinitionId), "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_secondary_background_color, overlay.secondary_background_color, "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_primary_attribute, overlay.primary_attribute, "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_secondary_attribute, overlay.secondary_attribute, "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_issued_date_attribute, overlay.issued_date_attribute, "f");
+        __classPrivateFieldSet(this, _BrandingOverlay_expiry_date_attribute, overlay.expiry_date_attribute, "f");
+    }
+    get backgroundImage() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_background_image, "f");
+    }
+    get backgroundImageSlice() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_background_image_slice, "f");
+    }
+    get primaryBackgroundColor() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_primary_background_color, "f");
+    }
+    get secondaryBackgroundColor() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_secondary_background_color, "f");
+    }
+    get primaryAttribute() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_primary_attribute, "f");
+    }
+    get secondaryAttribute() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_secondary_attribute, "f");
+    }
+    get issuedDateAttribute() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_issued_date_attribute, "f");
+    }
+    get expiryDateAttribute() {
+        return __classPrivateFieldGet(this, _BrandingOverlay_expiry_date_attribute, "f");
+    }
+}
+_BrandingOverlay_background_image = new WeakMap(), _BrandingOverlay_background_image_slice = new WeakMap(), _BrandingOverlay_primary_background_color = new WeakMap(), _BrandingOverlay_secondary_background_color = new WeakMap(), _BrandingOverlay_primary_attribute = new WeakMap(), _BrandingOverlay_secondary_attribute = new WeakMap(), _BrandingOverlay_issued_date_attribute = new WeakMap(), _BrandingOverlay_expiry_date_attribute = new WeakMap();
+exports.default = BrandingOverlay;

package/build/types/branding/LegacyBrandingOverlay.d.ts

@@ -0,0 +1,18 @@
+import { ILegacyBrandingOverlayData } from '../../interfaces/data';
+import BaseOverlay from '../base/BaseOverlay';
+export default class LegacyBrandingOverlay extends BaseOverlay {
+    #private;
+    header?: {
+        color?: string;
+        backgroundColor?: string;
+        imageSource?: string;
+        hideIssuer?: boolean;
+    };
+    footer?: {
+        color?: string;
+        backgroundColor?: string;
+    };
+    constructor(credentialDefinitionId: string, overlay: ILegacyBrandingOverlayData);
+    get backgroundColor(): string;
+    get imageSource(): string | undefined;
+}

package/build/types/branding/LegacyBrandingOverlay.js

@@ -0,0 +1,51 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LegacyBrandingOverlay_background_color, _LegacyBrandingOverlay_image_source;
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("../../utils/color");
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+class LegacyBrandingOverlay extends BaseOverlay_1.default {
+    constructor(credentialDefinitionId, overlay) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super(overlay);
+        _LegacyBrandingOverlay_background_color.set(this, void 0);
+        _LegacyBrandingOverlay_image_source.set(this, void 0);
+        __classPrivateFieldSet(this, _LegacyBrandingOverlay_background_color, (_a = overlay.background_color) !== null && _a !== void 0 ? _a : (0, color_1.generateColor)(credentialDefinitionId), "f");
+        __classPrivateFieldSet(this, _LegacyBrandingOverlay_image_source, overlay.image_source, "f");
+        if (overlay.header) {
+            this.header = {
+                color: (_b = overlay.header) === null || _b === void 0 ? void 0 : _b.color,
+                backgroundColor: (_c = overlay.header) === null || _c === void 0 ? void 0 : _c.background_color,
+                imageSource: (_d = overlay.header) === null || _d === void 0 ? void 0 : _d.image_source,
+                hideIssuer: (_e = overlay.header) === null || _e === void 0 ? void 0 : _e.hide_issuer,
+            };
+        }
+        if (overlay.footer) {
+            this.footer = {
+                color: (_f = overlay.footer) === null || _f === void 0 ? void 0 : _f.color,
+                backgroundColor: (_g = overlay.footer) === null || _g === void 0 ? void 0 : _g.background_color,
+            };
+        }
+    }
+    get backgroundColor() {
+        return __classPrivateFieldGet(this, _LegacyBrandingOverlay_background_color, "f");
+    }
+    get imageSource() {
+        return __classPrivateFieldGet(this, _LegacyBrandingOverlay_image_source, "f");
+    }
+}
+_LegacyBrandingOverlay_background_color = new WeakMap(), _LegacyBrandingOverlay_image_source = new WeakMap();
+exports.default = LegacyBrandingOverlay;

package/build/types/bundle/OverlayBundle.d.ts

@@ -0,0 +1,20 @@
+import { IOverlayBundleData } from '../../interfaces/data';
+import { IOverlayBundleAttribute, IOverlayBundleMetadata } from '../../interfaces/overlay';
+import BaseOverlay from '../base/BaseOverlay';
+import BrandingOverlay from '../branding/BrandingOverlay';
+import CaptureBase from '../capture-base/CaptureBase';
+declare class OverlayBundle {
+    #private;
+    credentialDefinitionId: string;
+    captureBase: CaptureBase;
+    overlays: BaseOverlay[];
+    languages: string[];
+    metadata: IOverlayBundleMetadata;
+    attributes: IOverlayBundleAttribute[];
+    flaggedAttributes: IOverlayBundleAttribute[];
+    constructor(credentialDefinitionId: string, bundle: IOverlayBundleData);
+    get branding(): BrandingOverlay | undefined;
+    getAttribute(name: string): IOverlayBundleAttribute | undefined;
+    getFlaggedAttribute(name: string): IOverlayBundleAttribute | undefined;
+}
+export default OverlayBundle;

package/build/types/bundle/OverlayBundle.js

@@ -0,0 +1,167 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _OverlayBundle_instances, _OverlayBundle_processMetadata, _OverlayBundle_processLanguages, _OverlayBundle_processOverlayAttributes, _OverlayBundle_processInformationForAttribute, _OverlayBundle_processLabelForAttribute, _OverlayBundle_processCharacterEncodingForAttribute, _OverlayBundle_processStandardForAttribute, _OverlayBundle_processFormatForAttribute, _OverlayBundle_overlaysForType;
+Object.defineProperty(exports, "__esModule", { value: true });
+const OverlayTypeMap_1 = __importDefault(require("../OverlayTypeMap"));
+const TypeEnums_1 = require("../TypeEnums");
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+const BrandingOverlay_1 = __importDefault(require("../branding/BrandingOverlay"));
+const LegacyBrandingOverlay_1 = __importDefault(require("../branding/LegacyBrandingOverlay"));
+const CaptureBase_1 = __importDefault(require("../capture-base/CaptureBase"));
+class OverlayBundle {
+    constructor(credentialDefinitionId, bundle) {
+        _OverlayBundle_instances.add(this);
+        this.credentialDefinitionId = credentialDefinitionId;
+        this.captureBase = new CaptureBase_1.default(bundle.capture_base);
+        this.overlays = bundle.overlays
+            .filter((overlay) => !overlay.type.startsWith('aries/overlays/branding/'))
+            .map((overlay) => {
+            const OverlayClass = (OverlayTypeMap_1.default.get(overlay.type) || BaseOverlay_1.default);
+            return new OverlayClass(overlay);
+        });
+        this.overlays.push(...bundle.overlays
+            .filter((overlay) => overlay.type === TypeEnums_1.OverlayType.Branding01)
+            .map((overlay) => {
+            const OverlayClass = (OverlayTypeMap_1.default.get(overlay.type) ||
+                LegacyBrandingOverlay_1.default);
+            return new OverlayClass(credentialDefinitionId, overlay);
+        }));
+        this.overlays.push(...bundle.overlays
+            .filter((overlay) => overlay.type === TypeEnums_1.OverlayType.Branding10 || overlay.type === TypeEnums_1.OverlayType.Branding11)
+            .map((overlay) => {
+            const OverlayClass = (OverlayTypeMap_1.default.get(overlay.type) || BrandingOverlay_1.default);
+            return new OverlayClass(credentialDefinitionId, overlay);
+        }));
+        this.languages = __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processLanguages).call(this);
+        this.metadata = __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processMetadata).call(this);
+        this.attributes = __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processOverlayAttributes).call(this);
+        this.flaggedAttributes = this.attributes.filter((attribute) => this.captureBase.flaggedAttributes.includes(attribute.name));
+    }
+    get branding() {
+        return (__classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Branding10)[0] ||
+            __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Branding11)[0]);
+    }
+    getAttribute(name) {
+        return this.attributes.find((attribute) => attribute.name === name);
+    }
+    getFlaggedAttribute(name) {
+        return this.flaggedAttributes.find((attribute) => attribute.name === name);
+    }
+}
+_OverlayBundle_instances = new WeakSet(), _OverlayBundle_processMetadata = function _OverlayBundle_processMetadata() {
+    var _a;
+    const metadata = {
+        name: {},
+        description: {},
+        credentialHelpText: {},
+        credentialSupportUrl: {},
+        issuer: {},
+        issuerDescription: {},
+        issuerUrl: {},
+    };
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Meta10)) {
+        const language = (_a = overlay.language) !== null && _a !== void 0 ? _a : 'en';
+        const { name, description, credentialHelpText, credentialSupportUrl, issuer, issuerDescription, issuerUrl } = overlay;
+        if (name) {
+            metadata.name[language] = name;
+        }
+        if (description) {
+            metadata.description[language] = description;
+        }
+        if (credentialHelpText) {
+            metadata.credentialHelpText[language] = credentialHelpText;
+        }
+        if (credentialSupportUrl) {
+            metadata.credentialSupportUrl[language] = credentialSupportUrl;
+        }
+        if (issuer) {
+            metadata.issuer[language] = issuer;
+        }
+        if (issuerDescription) {
+            metadata.issuerDescription[language] = issuerDescription;
+        }
+        if (issuerUrl) {
+            metadata.issuerUrl[language] = issuerUrl;
+        }
+    }
+    return metadata;
+}, _OverlayBundle_processLanguages = function _OverlayBundle_processLanguages() {
+    const languages = [];
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Meta10)) {
+        const language = overlay.language;
+        if (language && !languages.includes(language)) {
+            languages.push(language);
+        }
+    }
+    languages.sort((a, b) => a.localeCompare(b));
+    return languages;
+}, _OverlayBundle_processOverlayAttributes = function _OverlayBundle_processOverlayAttributes() {
+    const attributes = [];
+    const attributeMap = new Map(Object.entries(this.captureBase.attributes));
+    for (const [name, type] of attributeMap) {
+        attributes.push({
+            name,
+            type,
+            information: __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processInformationForAttribute).call(this, name),
+            label: __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processLabelForAttribute).call(this, name),
+            characterEncoding: __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processCharacterEncodingForAttribute).call(this, name),
+            standard: __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processStandardForAttribute).call(this, name),
+            format: __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_processFormatForAttribute).call(this, name),
+        });
+    }
+    return attributes;
+}, _OverlayBundle_processInformationForAttribute = function _OverlayBundle_processInformationForAttribute(key) {
+    var _a, _b;
+    const information = {};
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Information10)) {
+        if ((_a = overlay.attributeInformation) === null || _a === void 0 ? void 0 : _a[key]) {
+            const language = (_b = overlay.language) !== null && _b !== void 0 ? _b : 'en';
+            information[language] = overlay.attributeInformation[key];
+        }
+    }
+    return information;
+}, _OverlayBundle_processLabelForAttribute = function _OverlayBundle_processLabelForAttribute(key) {
+    var _a, _b;
+    const label = {};
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Label10)) {
+        if ((_a = overlay.attributeLabels) === null || _a === void 0 ? void 0 : _a[key]) {
+            const language = (_b = overlay.language) !== null && _b !== void 0 ? _b : 'en';
+            label[language] = overlay.attributeLabels[key];
+        }
+    }
+    return label;
+}, _OverlayBundle_processCharacterEncodingForAttribute = function _OverlayBundle_processCharacterEncodingForAttribute(key) {
+    var _a;
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.CharacterEncoding10)) {
+        if ((_a = overlay.attributeCharacterEncoding) === null || _a === void 0 ? void 0 : _a[key]) {
+            return overlay.attributeCharacterEncoding[key];
+        }
+    }
+    return;
+}, _OverlayBundle_processStandardForAttribute = function _OverlayBundle_processStandardForAttribute(key) {
+    var _a;
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Standard10)) {
+        if ((_a = overlay.attributeStandards) === null || _a === void 0 ? void 0 : _a[key]) {
+            return overlay.attributeStandards[key];
+        }
+    }
+    return;
+}, _OverlayBundle_processFormatForAttribute = function _OverlayBundle_processFormatForAttribute(key) {
+    var _a;
+    for (const overlay of __classPrivateFieldGet(this, _OverlayBundle_instances, "m", _OverlayBundle_overlaysForType).call(this, TypeEnums_1.OverlayType.Format10)) {
+        if ((_a = overlay.attributeFormats) === null || _a === void 0 ? void 0 : _a[key]) {
+            return overlay.attributeFormats[key];
+        }
+    }
+    return;
+}, _OverlayBundle_overlaysForType = function _OverlayBundle_overlaysForType(type) {
+    return this.overlays.filter((overlay) => overlay.type === type);
+};
+exports.default = OverlayBundle;

package/build/types/capture-base/CaptureBase.d.ts

@@ -0,0 +1,10 @@
+import { ICaptureBaseData } from '../../interfaces/data';
+export default class CaptureBase {
+    #private;
+    type: string;
+    classification: string;
+    attributes: Record<string, string>;
+    digest: string;
+    constructor(captureBase: ICaptureBaseData);
+    get flaggedAttributes(): string[];
+}

package/build/types/capture-base/CaptureBase.js

@@ -0,0 +1,30 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CaptureBase_flagged_attributes;
+Object.defineProperty(exports, "__esModule", { value: true });
+class CaptureBase {
+    constructor(captureBase) {
+        var _a;
+        _CaptureBase_flagged_attributes.set(this, void 0);
+        this.type = captureBase.type;
+        this.classification = captureBase.classification;
+        this.attributes = captureBase.attributes;
+        __classPrivateFieldSet(this, _CaptureBase_flagged_attributes, captureBase.flagged_attributes, "f");
+        this.digest = (_a = captureBase.digest) !== null && _a !== void 0 ? _a : '';
+    }
+    get flaggedAttributes() {
+        return __classPrivateFieldGet(this, _CaptureBase_flagged_attributes, "f");
+    }
+}
+_CaptureBase_flagged_attributes = new WeakMap();
+exports.default = CaptureBase;

package/build/types/index.d.ts

@@ -0,0 +1,14 @@
+import OverlayTypeMap from './OverlayTypeMap';
+import { OverlayType, CaptureBaseAttributeType } from './TypeEnums';
+import BaseOverlay from './base/BaseOverlay';
+import BrandingOverlay from './branding/BrandingOverlay';
+import LegacyBrandingOverlay from './branding/LegacyBrandingOverlay';
+import OverlayBundle from './bundle/OverlayBundle';
+import CaptureBase from './capture-base/CaptureBase';
+import CharacterEncodingOverlay from './semantic/CharacterEncodingOverlay';
+import FormatOverlay from './semantic/FormatOverlay';
+import InformationOverlay from './semantic/InformationOverlay';
+import LabelOverlay from './semantic/LabelOverlay';
+import MetaOverlay from './semantic/MetaOverlay';
+import StandardOverlay from './semantic/StandardOverlay';
+export { OverlayType, CaptureBaseAttributeType, BaseOverlay, CaptureBase, OverlayBundle, BrandingOverlay, LegacyBrandingOverlay, CharacterEncodingOverlay, FormatOverlay, InformationOverlay, LabelOverlay, MetaOverlay, StandardOverlay, OverlayTypeMap, };

package/build/types/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlayTypeMap = exports.StandardOverlay = exports.MetaOverlay = exports.LabelOverlay = exports.InformationOverlay = exports.FormatOverlay = exports.CharacterEncodingOverlay = exports.LegacyBrandingOverlay = exports.BrandingOverlay = exports.OverlayBundle = exports.CaptureBase = exports.BaseOverlay = exports.CaptureBaseAttributeType = exports.OverlayType = void 0;
+const OverlayTypeMap_1 = __importDefault(require("./OverlayTypeMap"));
+exports.OverlayTypeMap = OverlayTypeMap_1.default;
+const TypeEnums_1 = require("./TypeEnums");
+Object.defineProperty(exports, "OverlayType", { enumerable: true, get: function () { return TypeEnums_1.OverlayType; } });
+Object.defineProperty(exports, "CaptureBaseAttributeType", { enumerable: true, get: function () { return TypeEnums_1.CaptureBaseAttributeType; } });
+const BaseOverlay_1 = __importDefault(require("./base/BaseOverlay"));
+exports.BaseOverlay = BaseOverlay_1.default;
+const BrandingOverlay_1 = __importDefault(require("./branding/BrandingOverlay"));
+exports.BrandingOverlay = BrandingOverlay_1.default;
+const LegacyBrandingOverlay_1 = __importDefault(require("./branding/LegacyBrandingOverlay"));
+exports.LegacyBrandingOverlay = LegacyBrandingOverlay_1.default;
+const OverlayBundle_1 = __importDefault(require("./bundle/OverlayBundle"));
+exports.OverlayBundle = OverlayBundle_1.default;
+const CaptureBase_1 = __importDefault(require("./capture-base/CaptureBase"));
+exports.CaptureBase = CaptureBase_1.default;
+const CharacterEncodingOverlay_1 = __importDefault(require("./semantic/CharacterEncodingOverlay"));
+exports.CharacterEncodingOverlay = CharacterEncodingOverlay_1.default;
+const FormatOverlay_1 = __importDefault(require("./semantic/FormatOverlay"));
+exports.FormatOverlay = FormatOverlay_1.default;
+const InformationOverlay_1 = __importDefault(require("./semantic/InformationOverlay"));
+exports.InformationOverlay = InformationOverlay_1.default;
+const LabelOverlay_1 = __importDefault(require("./semantic/LabelOverlay"));
+exports.LabelOverlay = LabelOverlay_1.default;
+const MetaOverlay_1 = __importDefault(require("./semantic/MetaOverlay"));
+exports.MetaOverlay = MetaOverlay_1.default;
+const StandardOverlay_1 = __importDefault(require("./semantic/StandardOverlay"));
+exports.StandardOverlay = StandardOverlay_1.default;

package/build/types/semantic/CharacterEncodingOverlay.d.ts

@@ -0,0 +1,9 @@
+import { ICharacterEncodingOverlayData } from '../../interfaces/data';
+import BaseOverlay from '../base/BaseOverlay';
+export default class CharacterEncodingOverlay extends BaseOverlay {
+    #private;
+    constructor(overlay: ICharacterEncodingOverlayData);
+    get defaultCharacterEncoding(): string | undefined;
+    get attrCharacterEncoding(): Record<string, string> | undefined;
+    get attributeCharacterEncoding(): Record<string, string> | undefined;
+}

package/build/types/semantic/CharacterEncodingOverlay.js

@@ -0,0 +1,43 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _CharacterEncodingOverlay_default_character_encoding, _CharacterEncodingOverlay_attr_character_encoding, _CharacterEncodingOverlay_attribute_character_encoding;
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+class CharacterEncodingOverlay extends BaseOverlay_1.default {
+    constructor(overlay) {
+        super(overlay);
+        _CharacterEncodingOverlay_default_character_encoding.set(this, void 0);
+        // DEPRECATED - Use #attribute_character_encoding instead
+        _CharacterEncodingOverlay_attr_character_encoding.set(this, void 0);
+        _CharacterEncodingOverlay_attribute_character_encoding.set(this, void 0);
+        __classPrivateFieldSet(this, _CharacterEncodingOverlay_default_character_encoding, overlay.default_character_encoding, "f");
+        // DEPRECATED - Use #attribute_character_encoding instead
+        __classPrivateFieldSet(this, _CharacterEncodingOverlay_attr_character_encoding, overlay.attr_character_encoding, "f");
+        __classPrivateFieldSet(this, _CharacterEncodingOverlay_attribute_character_encoding, overlay.attribute_character_encoding, "f");
+    }
+    get defaultCharacterEncoding() {
+        return __classPrivateFieldGet(this, _CharacterEncodingOverlay_default_character_encoding, "f");
+    }
+    // DEPRECATED - Use attributeCharacterEncoding instead
+    get attrCharacterEncoding() {
+        return __classPrivateFieldGet(this, _CharacterEncodingOverlay_attr_character_encoding, "f");
+    }
+    get attributeCharacterEncoding() {
+        return __classPrivateFieldGet(this, _CharacterEncodingOverlay_attribute_character_encoding, "f");
+    }
+}
+_CharacterEncodingOverlay_default_character_encoding = new WeakMap(), _CharacterEncodingOverlay_attr_character_encoding = new WeakMap(), _CharacterEncodingOverlay_attribute_character_encoding = new WeakMap();
+exports.default = CharacterEncodingOverlay;

package/build/types/semantic/FormatOverlay.d.ts

@@ -0,0 +1,7 @@
+import { IFormatOverlayData } from '../../interfaces/data';
+import BaseOverlay from '../base/BaseOverlay';
+export default class FormatOverlay extends BaseOverlay {
+    #private;
+    constructor(overlay: IFormatOverlayData);
+    get attributeFormats(): Record<string, string>;
+}

package/build/types/semantic/FormatOverlay.js

@@ -0,0 +1,30 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _FormatOverlay_attribute_formats;
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+class FormatOverlay extends BaseOverlay_1.default {
+    constructor(overlay) {
+        super(overlay);
+        _FormatOverlay_attribute_formats.set(this, void 0);
+        __classPrivateFieldSet(this, _FormatOverlay_attribute_formats, overlay.attribute_formats, "f");
+    }
+    get attributeFormats() {
+        return __classPrivateFieldGet(this, _FormatOverlay_attribute_formats, "f");
+    }
+}
+_FormatOverlay_attribute_formats = new WeakMap();
+exports.default = FormatOverlay;

package/build/types/semantic/InformationOverlay.d.ts

@@ -0,0 +1,8 @@
+import { IInformationOverlayData } from '../../interfaces/data';
+import BaseOverlay from '../base/BaseOverlay';
+export default class InformationOverlay extends BaseOverlay {
+    #private;
+    language: string;
+    constructor(overlay: IInformationOverlayData);
+    get attributeInformation(): Record<string, string>;
+}

package/build/types/semantic/InformationOverlay.js

@@ -0,0 +1,31 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _InformationOverlay_attribute_information;
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+class InformationOverlay extends BaseOverlay_1.default {
+    constructor(overlay) {
+        super(overlay);
+        _InformationOverlay_attribute_information.set(this, void 0);
+        this.language = overlay.language;
+        __classPrivateFieldSet(this, _InformationOverlay_attribute_information, overlay.attribute_information, "f");
+    }
+    get attributeInformation() {
+        return __classPrivateFieldGet(this, _InformationOverlay_attribute_information, "f");
+    }
+}
+_InformationOverlay_attribute_information = new WeakMap();
+exports.default = InformationOverlay;

package/build/types/semantic/LabelOverlay.d.ts

@@ -0,0 +1,10 @@
+import { ILabelOverlayData } from '../../interfaces/data';
+import BaseOverlay from '../base/BaseOverlay';
+export default class LabelOverlay extends BaseOverlay {
+    #private;
+    language: string;
+    constructor(overlay: ILabelOverlayData);
+    get attributeLabels(): Record<string, string>;
+    get attributeCategories(): string[] | undefined;
+    get categoryLabels(): Record<string, string> | undefined;
+}

package/build/types/semantic/LabelOverlay.js

@@ -0,0 +1,41 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LabelOverlay_attribute_labels, _LabelOverlay_attribute_categories, _LabelOverlay_category_labels;
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseOverlay_1 = __importDefault(require("../base/BaseOverlay"));
+class LabelOverlay extends BaseOverlay_1.default {
+    constructor(overlay) {
+        super(overlay);
+        _LabelOverlay_attribute_labels.set(this, void 0);
+        _LabelOverlay_attribute_categories.set(this, void 0);
+        _LabelOverlay_category_labels.set(this, void 0);
+        this.language = overlay.language;
+        __classPrivateFieldSet(this, _LabelOverlay_attribute_labels, overlay.attribute_labels, "f");
+        __classPrivateFieldSet(this, _LabelOverlay_attribute_categories, overlay.attribute_categories, "f");
+        __classPrivateFieldSet(this, _LabelOverlay_category_labels, overlay.category_labels, "f");
+    }
+    get attributeLabels() {
+        return __classPrivateFieldGet(this, _LabelOverlay_attribute_labels, "f");
+    }
+    get attributeCategories() {
+        return __classPrivateFieldGet(this, _LabelOverlay_attribute_categories, "f");
+    }
+    get categoryLabels() {
+        return __classPrivateFieldGet(this, _LabelOverlay_category_labels, "f");
+    }
+}
+_LabelOverlay_attribute_labels = new WeakMap(), _LabelOverlay_attribute_categories = new WeakMap(), _LabelOverlay_category_labels = new WeakMap();
+exports.default = LabelOverlay;

package/build/types/semantic/MetaOverlay.d.ts

@@ -0,0 +1,15 @@
+import { IMetaOverlayData } from '../../interfaces/data';
+import BaseOverlay from '../base/BaseOverlay';
+export default class MetaOverlay extends BaseOverlay {
+    #private;
+    language: string;
+    name?: string;
+    description?: string;
+    issuer?: string;
+    constructor(overlay: IMetaOverlayData);
+    get credentialHelpText(): string | undefined;
+    get credentialSupportUrl(): string | undefined;
+    get issuerDescription(): string | undefined;
+    get issuerUrl(): string | undefined;
+    get watermark(): string | undefined;
+}