@nmshd/transport 1.0.0

package/dist/modules/certificates/data/constraints/CertificateBorderConstraint.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificateBorderConstraint_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateBorderConstraint = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const CertificateConstraint_1 = require("../CertificateConstraint");
+/**
+ * A CertificateBorderConstraint specifies a state, a country or a union in which
+ * this certificate should be valid.
+ *
+ * This constraint is primarily telling any verifier, that the issuer of the certificate does not
+ * hold the eligibility to issue a certificate anywhere else. Thus, the certificate should be
+ * treated as not valid outside the specified border.
+ *
+ * However, showing a certificate which is valid within a certain country (e.g. Germany) might be
+ * much better than not having a certificate at all. Therefore, the verifier could still treat this
+ * certificate as valid, although the issuer is no longer taking liability.
+ *
+ * Examples:
+ *  - Freight papers for the EU
+ *  - Access rights to buildings of the UN
+ *  - German driver license
+ */
+let CertificateBorderConstraint = CertificateBorderConstraint_1 = class CertificateBorderConstraint extends CertificateConstraint_1.CertificateConstraint {
+    static async from(value) {
+        return await super.fromT(value, CertificateBorderConstraint_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateBorderConstraint.prototype, "union", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateBorderConstraint.prototype, "country", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateBorderConstraint.prototype, "state", void 0);
+CertificateBorderConstraint = CertificateBorderConstraint_1 = __decorate([
+    (0, ts_serval_1.type)("CertificateBorderConstraint")
+], CertificateBorderConstraint);
+exports.CertificateBorderConstraint = CertificateBorderConstraint;
+//# sourceMappingURL=CertificateBorderConstraint.js.map

package/dist/modules/certificates/data/constraints/CertificateBorderConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificateBorderConstraint.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/constraints/CertificateBorderConstraint.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,oEAAwF;AAQxF;;;;;;;;;;;;;;;;GAgBG;AAEH,IAAa,2BAA2B,mCAAxC,MAAa,2BAA4B,SAAQ,6CAAqB;IAa3D,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAmC;QACxD,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,6BAA2B,CAAC,CAAA;IAChE,CAAC;CACJ,CAAA;AAbG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;0DACQ;AAIpB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;4DACU;AAItB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;0DACQ;AAXX,2BAA2B;IADvC,IAAA,gBAAI,EAAC,6BAA6B,CAAC;GACvB,2BAA2B,CAgBvC;AAhBY,kEAA2B"}

package/dist/modules/certificates/data/constraints/CertificateCityConstraint.d.ts

@@ -0,0 +1,31 @@
+import { CertificateConstraint, ICertificateConstraint } from "../CertificateConstraint";
+export interface ICertificateCityConstraint extends ICertificateConstraint {
+    city: string;
+    zipCode: string;
+}
+/**
+ * A CertificateCityConstraint specifies the district, city and zip code in which the
+ * certificate is valid.
+ *
+ * This constraint is primarily telling any verifier, that the issuer of the certificate does not
+ * hold the eligibility to issue a certificate anywhere else. Thus, the certificate should be
+ * treated as not valid outside the specified city.
+ *
+ * However, showing a certificate which is valid within a certain city (e.g. Cologne) might be
+ * much better than not having a certificate at all. Therefore, the verifier could still treat this
+ * certificate as valid, although the issuer is no longer taking liability.
+ *
+ * Consider using a CertificateBorderConstraint with a CertificateCityConstraint, otherwise the city
+ * could not be unique in the world.
+ *
+ * Examples:
+ *  - Parking permits within a city
+ *  - Public transport tickets
+ *  - City-Inhabitant IDs
+ */
+export declare class CertificateCityConstraint extends CertificateConstraint {
+    district: string;
+    city: string;
+    zipCode: string;
+    static from(value: ICertificateCityConstraint): Promise<CertificateCityConstraint>;
+}

package/dist/modules/certificates/data/constraints/CertificateCityConstraint.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificateCityConstraint_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateCityConstraint = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const CertificateConstraint_1 = require("../CertificateConstraint");
+/**
+ * A CertificateCityConstraint specifies the district, city and zip code in which the
+ * certificate is valid.
+ *
+ * This constraint is primarily telling any verifier, that the issuer of the certificate does not
+ * hold the eligibility to issue a certificate anywhere else. Thus, the certificate should be
+ * treated as not valid outside the specified city.
+ *
+ * However, showing a certificate which is valid within a certain city (e.g. Cologne) might be
+ * much better than not having a certificate at all. Therefore, the verifier could still treat this
+ * certificate as valid, although the issuer is no longer taking liability.
+ *
+ * Consider using a CertificateBorderConstraint with a CertificateCityConstraint, otherwise the city
+ * could not be unique in the world.
+ *
+ * Examples:
+ *  - Parking permits within a city
+ *  - Public transport tickets
+ *  - City-Inhabitant IDs
+ */
+let CertificateCityConstraint = CertificateCityConstraint_1 = class CertificateCityConstraint extends CertificateConstraint_1.CertificateConstraint {
+    static async from(value) {
+        return await super.fromT(value, CertificateCityConstraint_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateCityConstraint.prototype, "district", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateCityConstraint.prototype, "city", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateCityConstraint.prototype, "zipCode", void 0);
+CertificateCityConstraint = CertificateCityConstraint_1 = __decorate([
+    (0, ts_serval_1.type)("CertificateCityConstraint")
+], CertificateCityConstraint);
+exports.CertificateCityConstraint = CertificateCityConstraint;
+//# sourceMappingURL=CertificateCityConstraint.js.map

package/dist/modules/certificates/data/constraints/CertificateCityConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificateCityConstraint.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/constraints/CertificateCityConstraint.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,oEAAwF;AAOxF;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,IAAa,yBAAyB,iCAAtC,MAAa,yBAA0B,SAAQ,6CAAqB;IAazD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAiC;QACtD,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,2BAAyB,CAAC,CAAA;IAC9D,CAAC;CACJ,CAAA;AAbG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;2DACW;AAIvB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;uDACO;AAInB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;0DACU;AAXb,yBAAyB;IADrC,IAAA,gBAAI,EAAC,2BAA2B,CAAC;GACrB,yBAAyB,CAgBrC;AAhBY,8DAAyB"}

package/dist/modules/certificates/data/constraints/CertificateIdentityConstraint.d.ts

@@ -0,0 +1,9 @@
+import { CoreAddress, ICoreAddress } from "../../../../core";
+import { CertificateConstraint, ICertificateConstraint } from "../CertificateConstraint";
+export interface ICertificateIdentityConstraint extends ICertificateConstraint {
+    identity: ICoreAddress;
+}
+export declare class CertificateIdentityConstraint extends CertificateConstraint {
+    identity: CoreAddress;
+    static from(value: ICertificateIdentityConstraint): Promise<CertificateIdentityConstraint>;
+}

package/dist/modules/certificates/data/constraints/CertificateIdentityConstraint.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificateIdentityConstraint_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateIdentityConstraint = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const core_1 = require("../../../../core");
+const CertificateConstraint_1 = require("../CertificateConstraint");
+let CertificateIdentityConstraint = CertificateIdentityConstraint_1 = class CertificateIdentityConstraint extends CertificateConstraint_1.CertificateConstraint {
+    static async from(value) {
+        return await super.fromT(value, CertificateIdentityConstraint_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", core_1.CoreAddress)
+], CertificateIdentityConstraint.prototype, "identity", void 0);
+CertificateIdentityConstraint = CertificateIdentityConstraint_1 = __decorate([
+    (0, ts_serval_1.type)("CertificateIdentityConstraint")
+], CertificateIdentityConstraint);
+exports.CertificateIdentityConstraint = CertificateIdentityConstraint;
+//# sourceMappingURL=CertificateIdentityConstraint.js.map

package/dist/modules/certificates/data/constraints/CertificateIdentityConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificateIdentityConstraint.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/constraints/CertificateIdentityConstraint.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,2CAA4D;AAC5D,oEAAwF;AAOxF,IAAa,6BAA6B,qCAA1C,MAAa,6BAA8B,SAAQ,6CAAqB;IAK7D,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAqC;QAC1D,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,+BAA6B,CAAC,CAAA;IAClE,CAAC;CACJ,CAAA;AALG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;8BACK,kBAAW;+DAAA;AAHnB,6BAA6B;IADzC,IAAA,gBAAI,EAAC,+BAA+B,CAAC;GACzB,6BAA6B,CAQzC;AARY,sEAA6B"}

package/dist/modules/certificates/data/constraints/CertificateTimeConstraint.d.ts

@@ -0,0 +1,16 @@
+import { CoreDate, ICoreDate } from "../../../../core";
+import { CertificateConstraint, ICertificateConstraint } from "../CertificateConstraint";
+export interface ICertificateTimeConstraint extends ICertificateConstraint {
+    validFrom: ICoreDate;
+    validTo: ICoreDate;
+}
+/**
+ * A CertificateTimeConstraint limits the validity of the certificate to the specified
+ * dates. The certificate is not valid before the validFrom date, and not after the
+ * validTo date.
+ */
+export declare class CertificateTimeConstraint extends CertificateConstraint {
+    validFrom: CoreDate;
+    validTo: CoreDate;
+    static from(value: ICertificateTimeConstraint): Promise<CertificateTimeConstraint>;
+}

package/dist/modules/certificates/data/constraints/CertificateTimeConstraint.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificateTimeConstraint_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateTimeConstraint = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const core_1 = require("../../../../core");
+const CertificateConstraint_1 = require("../CertificateConstraint");
+/**
+ * A CertificateTimeConstraint limits the validity of the certificate to the specified
+ * dates. The certificate is not valid before the validFrom date, and not after the
+ * validTo date.
+ */
+let CertificateTimeConstraint = CertificateTimeConstraint_1 = class CertificateTimeConstraint extends CertificateConstraint_1.CertificateConstraint {
+    static async from(value) {
+        return await super.fromT(value, CertificateTimeConstraint_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", core_1.CoreDate)
+], CertificateTimeConstraint.prototype, "validFrom", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", core_1.CoreDate)
+], CertificateTimeConstraint.prototype, "validTo", void 0);
+CertificateTimeConstraint = CertificateTimeConstraint_1 = __decorate([
+    (0, ts_serval_1.type)("CertificateTimeConstraint")
+], CertificateTimeConstraint);
+exports.CertificateTimeConstraint = CertificateTimeConstraint;
+//# sourceMappingURL=CertificateTimeConstraint.js.map

package/dist/modules/certificates/data/constraints/CertificateTimeConstraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificateTimeConstraint.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/constraints/CertificateTimeConstraint.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,2CAAsD;AACtD,oEAAwF;AAOxF;;;;GAIG;AAEH,IAAa,yBAAyB,iCAAtC,MAAa,yBAA0B,SAAQ,6CAAqB;IASzD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAiC;QACtD,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,2BAAyB,CAAC,CAAA;IAC9D,CAAC;CACJ,CAAA;AATG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;8BACM,eAAQ;4DAAA;AAI1B;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;8BACI,eAAQ;0DAAA;AAPf,yBAAyB;IADrC,IAAA,gBAAI,EAAC,2BAA2B,CAAC;GACrB,yBAAyB,CAYrC;AAZY,8DAAyB"}

package/dist/modules/certificates/data/items/CertificateAuthorizationItem.d.ts

@@ -0,0 +1,17 @@
+import { CertificateItem, ICertificateItem } from "../CertificateItem";
+export interface ICertificateAuthorizationItem extends ICertificateItem {
+    authorization: string;
+}
+/**
+ * A CertificateAuthorizationItem gives a certain authorization, from the issuer to the
+ * subject.
+ *
+ * Example:
+ *  - Access Service XYZ
+ *  - Admin access to a computer
+ *  - Facility access to a visitor
+ */
+export declare class CertificateAuthorizationItem extends CertificateItem {
+    authorization: string;
+    static from(value: ICertificateAuthorizationItem): Promise<CertificateAuthorizationItem>;
+}

package/dist/modules/certificates/data/items/CertificateAuthorizationItem.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificateAuthorizationItem_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateAuthorizationItem = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const CertificateItem_1 = require("../CertificateItem");
+/**
+ * A CertificateAuthorizationItem gives a certain authorization, from the issuer to the
+ * subject.
+ *
+ * Example:
+ *  - Access Service XYZ
+ *  - Admin access to a computer
+ *  - Facility access to a visitor
+ */
+let CertificateAuthorizationItem = CertificateAuthorizationItem_1 = class CertificateAuthorizationItem extends CertificateItem_1.CertificateItem {
+    static async from(value) {
+        return await super.fromT(value, CertificateAuthorizationItem_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateAuthorizationItem.prototype, "authorization", void 0);
+CertificateAuthorizationItem = CertificateAuthorizationItem_1 = __decorate([
+    (0, ts_serval_1.type)("CertificateAuthorizationItem")
+], CertificateAuthorizationItem);
+exports.CertificateAuthorizationItem = CertificateAuthorizationItem;
+//# sourceMappingURL=CertificateAuthorizationItem.js.map

package/dist/modules/certificates/data/items/CertificateAuthorizationItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificateAuthorizationItem.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/items/CertificateAuthorizationItem.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,wDAAsE;AAMtE;;;;;;;;GAQG;AAEH,IAAa,4BAA4B,oCAAzC,MAAa,4BAA6B,SAAQ,iCAAe;IAKtD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAoC;QACzD,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,8BAA4B,CAAC,CAAA;IACjE,CAAC;CACJ,CAAA;AALG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;mEACgB;AAHnB,4BAA4B;IADxC,IAAA,gBAAI,EAAC,8BAA8B,CAAC;GACxB,4BAA4B,CAQxC;AARY,oEAA4B"}

package/dist/modules/certificates/data/items/CertificateDelegateItem.d.ts

@@ -0,0 +1,18 @@
+import { CertificateItem, ICertificateItem } from "../CertificateItem";
+export interface ICertificateDelegateItem extends ICertificateItem {
+}
+export declare enum CertificateDelegateType {
+    Clone = "clone",
+    Custodian = "custodian",
+    Sign = "sign",
+    Ppa = "ppa",
+    Communication = "communication"
+}
+/**
+ * A CertificateDelegateItem
+ */
+export declare class CertificateDelegateItem extends CertificateItem {
+    type: CertificateDelegateType;
+    content: string;
+    static from(value: ICertificateDelegateItem): Promise<CertificateDelegateItem>;
+}

package/dist/modules/certificates/data/items/CertificateDelegateItem.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificateDelegateItem_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateDelegateItem = exports.CertificateDelegateType = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const CertificateItem_1 = require("../CertificateItem");
+var CertificateDelegateType;
+(function (CertificateDelegateType) {
+    CertificateDelegateType["Clone"] = "clone";
+    CertificateDelegateType["Custodian"] = "custodian";
+    CertificateDelegateType["Sign"] = "sign";
+    CertificateDelegateType["Ppa"] = "ppa";
+    CertificateDelegateType["Communication"] = "communication";
+})(CertificateDelegateType = exports.CertificateDelegateType || (exports.CertificateDelegateType = {}));
+/**
+ * A CertificateDelegateItem
+ */
+let CertificateDelegateItem = CertificateDelegateItem_1 = class CertificateDelegateItem extends CertificateItem_1.CertificateItem {
+    static async from(value) {
+        return await super.fromT(value, CertificateDelegateItem_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateDelegateItem.prototype, "type", void 0);
+__decorate([
+    (0, ts_serval_1.validate)({ nullable: true }),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificateDelegateItem.prototype, "content", void 0);
+CertificateDelegateItem = CertificateDelegateItem_1 = __decorate([
+    (0, ts_serval_1.type)("CertificateDelegateItem")
+], CertificateDelegateItem);
+exports.CertificateDelegateItem = CertificateDelegateItem;
+//# sourceMappingURL=CertificateDelegateItem.js.map

package/dist/modules/certificates/data/items/CertificateDelegateItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificateDelegateItem.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/items/CertificateDelegateItem.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,wDAAsE;AAItE,IAAY,uBAMX;AAND,WAAY,uBAAuB;IAC/B,0CAAe,CAAA;IACf,kDAAuB,CAAA;IACvB,wCAAa,CAAA;IACb,sCAAW,CAAA;IACX,0DAA+B,CAAA;AACnC,CAAC,EANW,uBAAuB,GAAvB,+BAAuB,KAAvB,+BAAuB,QAMlC;AAED;;GAEG;AAEH,IAAa,uBAAuB,+BAApC,MAAa,uBAAwB,SAAQ,iCAAe;IASjD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAA+B;QACpD,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,yBAAuB,CAAC,CAAA;IAC5D,CAAC;CACJ,CAAA;AATG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;qDACwB;AAIpC;IAFC,IAAA,oBAAQ,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC5B,IAAA,qBAAS,GAAE;;wDACU;AAPb,uBAAuB;IADnC,IAAA,gBAAI,EAAC,yBAAyB,CAAC;GACnB,uBAAuB,CAYnC;AAZY,0DAAuB"}

package/dist/modules/certificates/data/items/CertificatePrivateAttributeItem.d.ts

@@ -0,0 +1,19 @@
+import { CoreHash } from "../../../../core/types";
+import { CertificateItem, ICertificateItem } from "../CertificateItem";
+export interface ICertificatePrivateAttributeItem extends ICertificateItem {
+}
+/**
+ * A CertificatePrivateAttributeItem is a hashed representation of a single attribute,
+ * consisting of a user-defined random nonce, the name of the attribute and its value.
+ *
+ * With this approach, one Certificate can be used for certifying multiple attributes,
+ * but without leaking any private/confidential data. A user can still select the attributes to
+ * share with a third party (e.g. name, address, email) while submitting a Certificate
+ * certifying much more data (e.g. name, address, email, mobile, birthdate, tax id, ...). However,
+ * the additional data within the shared certificate is of no value to the third party, without
+ * the shared attributes (+ nonce).
+ */
+export declare class CertificatePrivateAttributeItem extends CertificateItem {
+    hash: CoreHash;
+    static from(value: ICertificatePrivateAttributeItem): Promise<CertificatePrivateAttributeItem>;
+}

package/dist/modules/certificates/data/items/CertificatePrivateAttributeItem.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificatePrivateAttributeItem_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificatePrivateAttributeItem = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const types_1 = require("../../../../core/types");
+const CertificateItem_1 = require("../CertificateItem");
+/**
+ * A CertificatePrivateAttributeItem is a hashed representation of a single attribute,
+ * consisting of a user-defined random nonce, the name of the attribute and its value.
+ *
+ * With this approach, one Certificate can be used for certifying multiple attributes,
+ * but without leaking any private/confidential data. A user can still select the attributes to
+ * share with a third party (e.g. name, address, email) while submitting a Certificate
+ * certifying much more data (e.g. name, address, email, mobile, birthdate, tax id, ...). However,
+ * the additional data within the shared certificate is of no value to the third party, without
+ * the shared attributes (+ nonce).
+ */
+let CertificatePrivateAttributeItem = CertificatePrivateAttributeItem_1 = class CertificatePrivateAttributeItem extends CertificateItem_1.CertificateItem {
+    static async from(value) {
+        return await super.fromT(value, CertificatePrivateAttributeItem_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", types_1.CoreHash)
+], CertificatePrivateAttributeItem.prototype, "hash", void 0);
+CertificatePrivateAttributeItem = CertificatePrivateAttributeItem_1 = __decorate([
+    (0, ts_serval_1.type)("CertificatePrivateAttributeItem")
+], CertificatePrivateAttributeItem);
+exports.CertificatePrivateAttributeItem = CertificatePrivateAttributeItem;
+//# sourceMappingURL=CertificatePrivateAttributeItem.js.map

package/dist/modules/certificates/data/items/CertificatePrivateAttributeItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificatePrivateAttributeItem.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/items/CertificatePrivateAttributeItem.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,kDAAiD;AACjD,wDAAsE;AAItE;;;;;;;;;;GAUG;AAEH,IAAa,+BAA+B,uCAA5C,MAAa,+BAAgC,SAAQ,iCAAe;IAKzD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAuC;QAC5D,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,iCAA+B,CAAC,CAAA;IACpE,CAAC;CACJ,CAAA;AALG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;8BACC,gBAAQ;6DAAA;AAHZ,+BAA+B;IAD3C,IAAA,gBAAI,EAAC,iCAAiC,CAAC;GAC3B,+BAA+B,CAQ3C;AARY,0EAA+B"}

package/dist/modules/certificates/data/items/CertificatePrivateAttributeItemSource.d.ts

@@ -0,0 +1,25 @@
+import { CoreHash } from "../../../../core/types";
+import { CertificateItem, ICertificateItem } from "../CertificateItem";
+export interface ICertificatePrivateAttributeItemSource extends ICertificateItem {
+    nonce: string;
+    name: string;
+    value: string;
+}
+/**
+ * A CertificatePrivateAttributeItemSource is the cleartext version of a
+ * CertificatePrivateAttributeItem.
+ *
+ * With this approach, one Certificate can be used for certifying multiple attributes,
+ * but without leaking any private/confidential data. A user can still select the attributes to
+ * share with a third party (e.g. name, address, email) while submitting a Certificate
+ * certifying much more data (e.g. name, address, email, mobile, birthdate, tax id, ...). However,
+ * the additional data within the shared certificate is of no value to the third party, without
+ * the shared attributes (+ nonce).
+ */
+export declare class CertificatePrivateAttributeItemSource extends CertificateItem {
+    nonce: string;
+    name: string;
+    value: string;
+    hash(): Promise<CoreHash>;
+    static from(value: ICertificatePrivateAttributeItemSource): Promise<CertificatePrivateAttributeItemSource>;
+}

package/dist/modules/certificates/data/items/CertificatePrivateAttributeItemSource.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificatePrivateAttributeItemSource_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificatePrivateAttributeItemSource = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const types_1 = require("../../../../core/types");
+const CertificateItem_1 = require("../CertificateItem");
+/**
+ * A CertificatePrivateAttributeItemSource is the cleartext version of a
+ * CertificatePrivateAttributeItem.
+ *
+ * With this approach, one Certificate can be used for certifying multiple attributes,
+ * but without leaking any private/confidential data. A user can still select the attributes to
+ * share with a third party (e.g. name, address, email) while submitting a Certificate
+ * certifying much more data (e.g. name, address, email, mobile, birthdate, tax id, ...). However,
+ * the additional data within the shared certificate is of no value to the third party, without
+ * the shared attributes (+ nonce).
+ */
+let CertificatePrivateAttributeItemSource = CertificatePrivateAttributeItemSource_1 = class CertificatePrivateAttributeItemSource extends CertificateItem_1.CertificateItem {
+    async hash() {
+        return await types_1.CoreHash.hash(`${this.nonce}|${this.name}|${this.value}`);
+    }
+    static async from(value) {
+        return await super.fromT(value, CertificatePrivateAttributeItemSource_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificatePrivateAttributeItemSource.prototype, "nonce", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificatePrivateAttributeItemSource.prototype, "name", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificatePrivateAttributeItemSource.prototype, "value", void 0);
+CertificatePrivateAttributeItemSource = CertificatePrivateAttributeItemSource_1 = __decorate([
+    (0, ts_serval_1.type)("CertificatePrivateAttributeItem")
+], CertificatePrivateAttributeItemSource);
+exports.CertificatePrivateAttributeItemSource = CertificatePrivateAttributeItemSource;
+//# sourceMappingURL=CertificatePrivateAttributeItemSource.js.map

package/dist/modules/certificates/data/items/CertificatePrivateAttributeItemSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificatePrivateAttributeItemSource.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/items/CertificatePrivateAttributeItemSource.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,kDAAiD;AACjD,wDAAsE;AAQtE;;;;;;;;;;GAUG;AAEH,IAAa,qCAAqC,6CAAlD,MAAa,qCAAsC,SAAQ,iCAAe;IAa/D,KAAK,CAAC,IAAI;QACb,OAAO,MAAM,gBAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAA;IAC1E,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,IAAI,CACpB,KAA6C;QAE7C,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,uCAAqC,CAAC,CAAA;IAC1E,CAAC;CACJ,CAAA;AAnBG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;oEACQ;AAIpB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;mEACO;AAInB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;oEACQ;AAXX,qCAAqC;IADjD,IAAA,gBAAI,EAAC,iCAAiC,CAAC;GAC3B,qCAAqC,CAsBjD;AAtBY,sFAAqC"}

package/dist/modules/certificates/data/items/CertificatePublicAttributeItem.d.ts

@@ -0,0 +1,14 @@
+import { CertificateItem, ICertificateItem } from "../CertificateItem";
+export interface ICertificatePublicAttributeItem extends ICertificateItem {
+    name: string;
+    value: string;
+}
+/**
+ * A CertificatePublicAttributeItem is a representation of a single attribute,
+ * consisting of a name of the attribute and its value.
+ */
+export declare class CertificatePublicAttributeItem extends CertificateItem {
+    name: string;
+    value: string;
+    static from(value: ICertificatePublicAttributeItem): Promise<CertificatePublicAttributeItem>;
+}

package/dist/modules/certificates/data/items/CertificatePublicAttributeItem.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CertificatePublicAttributeItem_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificatePublicAttributeItem = void 0;
+const ts_serval_1 = require("@js-soft/ts-serval");
+const CertificateItem_1 = require("../CertificateItem");
+/**
+ * A CertificatePublicAttributeItem is a representation of a single attribute,
+ * consisting of a name of the attribute and its value.
+ */
+let CertificatePublicAttributeItem = CertificatePublicAttributeItem_1 = class CertificatePublicAttributeItem extends CertificateItem_1.CertificateItem {
+    static async from(value) {
+        return await super.fromT(value, CertificatePublicAttributeItem_1);
+    }
+};
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificatePublicAttributeItem.prototype, "name", void 0);
+__decorate([
+    (0, ts_serval_1.validate)(),
+    (0, ts_serval_1.serialize)(),
+    __metadata("design:type", String)
+], CertificatePublicAttributeItem.prototype, "value", void 0);
+CertificatePublicAttributeItem = CertificatePublicAttributeItem_1 = __decorate([
+    (0, ts_serval_1.type)("CertificatePublicAttributeItem")
+], CertificatePublicAttributeItem);
+exports.CertificatePublicAttributeItem = CertificatePublicAttributeItem;
+//# sourceMappingURL=CertificatePublicAttributeItem.js.map

package/dist/modules/certificates/data/items/CertificatePublicAttributeItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CertificatePublicAttributeItem.js","sourceRoot":"","sources":["../../../../../src/modules/certificates/data/items/CertificatePublicAttributeItem.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,kDAA8D;AAC9D,wDAAsE;AAOtE;;;GAGG;AAEH,IAAa,8BAA8B,sCAA3C,MAAa,8BAA+B,SAAQ,iCAAe;IASxD,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAsC;QAC3D,OAAO,MAAM,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,gCAA8B,CAAC,CAAA;IACnE,CAAC;CACJ,CAAA;AATG;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;4DACO;AAInB;IAFC,IAAA,oBAAQ,GAAE;IACV,IAAA,qBAAS,GAAE;;6DACQ;AAPX,8BAA8B;IAD1C,IAAA,gBAAI,EAAC,gCAAgC,CAAC;GAC1B,8BAA8B,CAY1C;AAZY,wEAA8B"}

package/dist/modules/certificates/data/items/CertificateRoleItem.d.ts

@@ -0,0 +1,16 @@
+import { CertificateItem, ICertificateItem } from "../CertificateItem";
+export interface ICertificateRoleItem extends ICertificateItem {
+    role: string;
+}
+/**
+ * A CertificateRoleItem certifies a certain role, that the subject got from
+ * the issuer.
+ *
+ * Example:
+ *  - Employee
+ *  - Administrator
+ */
+export declare class CertificateRoleItem extends CertificateItem {
+    role: string;
+    static from(value: ICertificateRoleItem): Promise<CertificateRoleItem>;
+}