@brightchain/brightchain-lib 0.29.22 → 0.29.25

package/src/lib/enumeration-translations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumeration-translations/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,aAAa,CAAC;AACjC,mBAAmB,aAAa,CAAC;AACjC,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,uBAAuB,CAAC;AAG3C,OAAO,aAAa,CAAC;AACrB,OAAO,aAAa,CAAC;AACrB,OAAO,cAAc,CAAC;AACtB,OAAO,0BAA0B,CAAC;AAClC,OAAO,2BAA2B,CAAC;AACnC,OAAO,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumeration-translations/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,aAAa,CAAC;AACjC,mBAAmB,aAAa,CAAC;AACjC,mBAAmB,+BAA+B,CAAC;AACnD,mBAAmB,cAAc,CAAC;AAClC,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,uBAAuB,CAAC;AAG3C,OAAO,aAAa,CAAC;AACrB,OAAO,aAAa,CAAC;AACrB,OAAO,+BAA+B,CAAC;AACvC,OAAO,cAAc,CAAC;AACtB,OAAO,2BAA2B,CAAC;AACnC,OAAO,uBAAuB,CAAC"}

package/src/lib/enumeration-translations/index.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // Import to ensure enum translations are registered at module load time
 require("./blockSize");
 require("./blockType");
+require("./brightTrustDataRecordAction");
 require("./memberType");
-require("./quorumDataRecordAction");
 require("./security-event-severity");
 require("./security-event-type");
 //# sourceMappingURL=index.js.map

package/src/lib/enumeration-translations/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumeration-translations/index.ts"],"names":[],"mappings":";;AAOA,wEAAwE;AACxE,uBAAqB;AACrB,uBAAqB;AACrB,wBAAsB;AACtB,oCAAkC;AAClC,qCAAmC;AACnC,iCAA+B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumeration-translations/index.ts"],"names":[],"mappings":";;AAOA,wEAAwE;AACxE,uBAAqB;AACrB,uBAAqB;AACrB,yCAAuC;AACvC,wBAAsB;AACtB,qCAAmC;AACnC,iCAA+B"}

package/src/lib/enumerations/actionEvent.d.ts

@@ -1,9 +1,9 @@
-export declare enum QuorumDataRecordActionEventType {
+export declare enum BrightTrustDataRecordActionEventType {
     Initiate = 0,
     Confirm = 1,
     Deny = 2,
     Cancel = 3,
     Override = 4
 }
-export default QuorumDataRecordActionEventType;
+export default BrightTrustDataRecordActionEventType;
 //# sourceMappingURL=actionEvent.d.ts.map

package/src/lib/enumerations/actionEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actionEvent.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionEvent.ts"],"names":[],"mappings":"AAAA,oBAAY,+BAA+B;IACzC,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,QAAQ,IAAA;CACT;AACD,eAAe,+BAA+B,CAAC"}
+{"version":3,"file":"actionEvent.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionEvent.ts"],"names":[],"mappings":"AAAA,oBAAY,oCAAoC;IAC9C,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,QAAQ,IAAA;CACT;AACD,eAAe,oCAAoC,CAAC"}

package/src/lib/enumerations/actionEvent.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuorumDataRecordActionEventType = void 0;
-var QuorumDataRecordActionEventType;
-(function (QuorumDataRecordActionEventType) {
-    QuorumDataRecordActionEventType[QuorumDataRecordActionEventType["Initiate"] = 0] = "Initiate";
-    QuorumDataRecordActionEventType[QuorumDataRecordActionEventType["Confirm"] = 1] = "Confirm";
-    QuorumDataRecordActionEventType[QuorumDataRecordActionEventType["Deny"] = 2] = "Deny";
-    QuorumDataRecordActionEventType[QuorumDataRecordActionEventType["Cancel"] = 3] = "Cancel";
-    QuorumDataRecordActionEventType[QuorumDataRecordActionEventType["Override"] = 4] = "Override";
-})(QuorumDataRecordActionEventType || (exports.QuorumDataRecordActionEventType = QuorumDataRecordActionEventType = {}));
-exports.default = QuorumDataRecordActionEventType;
+exports.BrightTrustDataRecordActionEventType = void 0;
+var BrightTrustDataRecordActionEventType;
+(function (BrightTrustDataRecordActionEventType) {
+    BrightTrustDataRecordActionEventType[BrightTrustDataRecordActionEventType["Initiate"] = 0] = "Initiate";
+    BrightTrustDataRecordActionEventType[BrightTrustDataRecordActionEventType["Confirm"] = 1] = "Confirm";
+    BrightTrustDataRecordActionEventType[BrightTrustDataRecordActionEventType["Deny"] = 2] = "Deny";
+    BrightTrustDataRecordActionEventType[BrightTrustDataRecordActionEventType["Cancel"] = 3] = "Cancel";
+    BrightTrustDataRecordActionEventType[BrightTrustDataRecordActionEventType["Override"] = 4] = "Override";
+})(BrightTrustDataRecordActionEventType || (exports.BrightTrustDataRecordActionEventType = BrightTrustDataRecordActionEventType = {}));
+exports.default = BrightTrustDataRecordActionEventType;
 //# sourceMappingURL=actionEvent.js.map

package/src/lib/enumerations/actionEvent.js.map

@@ -1 +1 @@
-{"version":3,"file":"actionEvent.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionEvent.ts"],"names":[],"mappings":";;;AAAA,IAAY,+BAMX;AAND,WAAY,+BAA+B;IACzC,6FAAQ,CAAA;IACR,2FAAO,CAAA;IACP,qFAAI,CAAA;IACJ,yFAAM,CAAA;IACN,6FAAQ,CAAA;AACV,CAAC,EANW,+BAA+B,+CAA/B,+BAA+B,QAM1C;AACD,kBAAe,+BAA+B,CAAC"}
+{"version":3,"file":"actionEvent.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionEvent.ts"],"names":[],"mappings":";;;AAAA,IAAY,oCAMX;AAND,WAAY,oCAAoC;IAC9C,uGAAQ,CAAA;IACR,qGAAO,CAAA;IACP,+FAAI,CAAA;IACJ,mGAAM,CAAA;IACN,uGAAQ,CAAA;AACV,CAAC,EANW,oCAAoC,oDAApC,oCAAoC,QAM/C;AACD,kBAAe,oCAAoC,CAAC"}

package/src/lib/enumerations/actionType.d.ts

@@ -1,9 +1,9 @@
-export declare enum QuorumDataRecordActionType {
+export declare enum BrightTrustDataRecordActionType {
     Seal = "Seal",
     Unseal = "Unseal",
     Reseal = "Reseal",
     ValidateHeldKeys = "ValidateHeldKeys",
     ValidateRecordIntegrity = "ValidateRecordIntegrity"
 }
-export default QuorumDataRecordActionType;
+export default BrightTrustDataRecordActionType;
 //# sourceMappingURL=actionType.d.ts.map

package/src/lib/enumerations/actionType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actionType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionType.ts"],"names":[],"mappings":"AAAA,oBAAY,0BAA0B;IACpC,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,gBAAgB,qBAAqB;IACrC,uBAAuB,4BAA4B;CACpD;AACD,eAAe,0BAA0B,CAAC"}
+{"version":3,"file":"actionType.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionType.ts"],"names":[],"mappings":"AAAA,oBAAY,+BAA+B;IACzC,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,gBAAgB,qBAAqB;IACrC,uBAAuB,4BAA4B;CACpD;AACD,eAAe,+BAA+B,CAAC"}

package/src/lib/enumerations/actionType.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuorumDataRecordActionType = void 0;
-var QuorumDataRecordActionType;
-(function (QuorumDataRecordActionType) {
-    QuorumDataRecordActionType["Seal"] = "Seal";
-    QuorumDataRecordActionType["Unseal"] = "Unseal";
-    QuorumDataRecordActionType["Reseal"] = "Reseal";
-    QuorumDataRecordActionType["ValidateHeldKeys"] = "ValidateHeldKeys";
-    QuorumDataRecordActionType["ValidateRecordIntegrity"] = "ValidateRecordIntegrity";
-})(QuorumDataRecordActionType || (exports.QuorumDataRecordActionType = QuorumDataRecordActionType = {}));
-exports.default = QuorumDataRecordActionType;
+exports.BrightTrustDataRecordActionType = void 0;
+var BrightTrustDataRecordActionType;
+(function (BrightTrustDataRecordActionType) {
+    BrightTrustDataRecordActionType["Seal"] = "Seal";
+    BrightTrustDataRecordActionType["Unseal"] = "Unseal";
+    BrightTrustDataRecordActionType["Reseal"] = "Reseal";
+    BrightTrustDataRecordActionType["ValidateHeldKeys"] = "ValidateHeldKeys";
+    BrightTrustDataRecordActionType["ValidateRecordIntegrity"] = "ValidateRecordIntegrity";
+})(BrightTrustDataRecordActionType || (exports.BrightTrustDataRecordActionType = BrightTrustDataRecordActionType = {}));
+exports.default = BrightTrustDataRecordActionType;
 //# sourceMappingURL=actionType.js.map

package/src/lib/enumerations/actionType.js.map

@@ -1 +1 @@
-{"version":3,"file":"actionType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionType.ts"],"names":[],"mappings":";;;AAAA,IAAY,0BAMX;AAND,WAAY,0BAA0B;IACpC,2CAAa,CAAA;IACb,+CAAiB,CAAA;IACjB,+CAAiB,CAAA;IACjB,mEAAqC,CAAA;IACrC,iFAAmD,CAAA;AACrD,CAAC,EANW,0BAA0B,0CAA1B,0BAA0B,QAMrC;AACD,kBAAe,0BAA0B,CAAC"}
+{"version":3,"file":"actionType.js","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/actionType.ts"],"names":[],"mappings":";;;AAAA,IAAY,+BAMX;AAND,WAAY,+BAA+B;IACzC,gDAAa,CAAA;IACb,oDAAiB,CAAA;IACjB,oDAAiB,CAAA;IACjB,wEAAqC,CAAA;IACrC,sFAAmD,CAAA;AACrD,CAAC,EANW,+BAA+B,+CAA/B,+BAA+B,QAM1C;AACD,kBAAe,+BAA+B,CAAC"}

package/src/lib/enumerations/brightChainStrings.d.ts

@@ -1,6 +1,12 @@
-import { BrandedStringKeyValue } from '@digitaldefiance/i18n-lib';
+import { type BrandedStringKeys, BrandedStringKeyValue } from '@digitaldefiance/i18n-lib';
 export declare const BrightChainComponentId = "BrightChain";
-export declare const BrightChainStrings: import("@digitaldefiance/i18n-lib").BrandedStringKeys<{
+declare const _brightChainKeys: {
+    readonly Common_Bright: "Common_Bright";
+    readonly Common_Chain: "Common_Chain";
+    readonly Common_Privacy: "Common_Privacy";
+    readonly Common_Participation: "Common_Participation";
+    readonly Common_Power: "Common_Power";
+    readonly Common_PrivacyParticipationPower: "Common_PrivacyParticipationPower";
     readonly Common_BlockSize: "Common_BlockSize";
     readonly Common_AtIndexTemplate: "Common_AtIndexTemplate";
     readonly Error_BlockAccess_Template: "Error_BlockAccess_Template";
@@ -320,48 +326,48 @@ export declare const BrightChainStrings: import("@digitaldefiance/i18n-lib").Bra
     readonly Error_IsolatedKeyError_InvalidKeyLength: "Error_IsolatedKeyError_InvalidKeyLength";
     readonly Error_IsolatedKeyError_InvalidKeyType: "Error_IsolatedKeyError_InvalidKeyType";
     readonly Error_IsolatedKeyError_KeyIsolationViolation: "Error_IsolatedKeyError_KeyIsolationViolation";
-    readonly Error_QuorumError_InvalidQuorumId: "Error_QuorumError_InvalidQuorumId";
-    readonly Error_QuorumError_DocumentNotFound: "Error_QuorumError_DocumentNotFound";
-    readonly Error_QuorumError_UnableToRestoreDocument: "Error_QuorumError_UnableToRestoreDocument";
-    readonly Error_QuorumError_NotImplemented: "Error_QuorumError_NotImplemented";
-    readonly Error_QuorumError_Uninitialized: "Error_QuorumError_Uninitialized";
-    readonly Error_QuorumError_MemberNotFound: "Error_QuorumError_MemberNotFound";
-    readonly Error_QuorumError_NotEnoughMembers: "Error_QuorumError_NotEnoughMembers";
-    readonly Error_QuorumError_TransitionInProgress: "Error_QuorumError_TransitionInProgress";
-    readonly Error_QuorumError_InvalidModeTransition: "Error_QuorumError_InvalidModeTransition";
-    readonly Error_QuorumError_InsufficientMembersForTransition: "Error_QuorumError_InsufficientMembersForTransition";
-    readonly Error_QuorumError_MemberAlreadyExists: "Error_QuorumError_MemberAlreadyExists";
-    readonly Error_QuorumError_InsufficientRemainingMembers: "Error_QuorumError_InsufficientRemainingMembers";
-    readonly Error_QuorumError_MemberBanned: "Error_QuorumError_MemberBanned";
-    readonly Error_QuorumError_MemberSuspended: "Error_QuorumError_MemberSuspended";
-    readonly Error_QuorumError_DuplicateProposal: "Error_QuorumError_DuplicateProposal";
-    readonly Error_QuorumError_ProposalExpired: "Error_QuorumError_ProposalExpired";
-    readonly Error_QuorumError_DuplicateVote: "Error_QuorumError_DuplicateVote";
-    readonly Error_QuorumError_VoterNotOnProposal: "Error_QuorumError_VoterNotOnProposal";
-    readonly Error_QuorumError_AuthenticationFailed: "Error_QuorumError_AuthenticationFailed";
-    readonly Error_QuorumError_VotingLocked: "Error_QuorumError_VotingLocked";
-    readonly Error_QuorumError_MissingAttachment: "Error_QuorumError_MissingAttachment";
-    readonly Error_QuorumError_AttachmentNotRetrievable: "Error_QuorumError_AttachmentNotRetrievable";
-    readonly Error_QuorumError_CannotBanSelf: "Error_QuorumError_CannotBanSelf";
-    readonly Error_QuorumError_MemberAlreadyBanned: "Error_QuorumError_MemberAlreadyBanned";
-    readonly Error_QuorumError_MemberNotBanned: "Error_QuorumError_MemberNotBanned";
-    readonly Error_QuorumError_NewMemberCannotProposeBan: "Error_QuorumError_NewMemberCannotProposeBan";
-    readonly Error_QuorumError_BanCoolingPeriodNotElapsed: "Error_QuorumError_BanCoolingPeriodNotElapsed";
-    readonly Error_QuorumError_InvalidBanRecordSignatures: "Error_QuorumError_InvalidBanRecordSignatures";
-    readonly Error_QuorumError_RedistributionFailed: "Error_QuorumError_RedistributionFailed";
-    readonly Error_QuorumError_InsufficientSharesForReconstruction: "Error_QuorumError_InsufficientSharesForReconstruction";
-    readonly Error_QuorumError_KeyReconstructionValidationFailed: "Error_QuorumError_KeyReconstructionValidationFailed";
-    readonly Error_QuorumError_IdentityPermanentlyUnrecoverable: "Error_QuorumError_IdentityPermanentlyUnrecoverable";
-    readonly Error_QuorumError_InvalidMembershipProof: "Error_QuorumError_InvalidMembershipProof";
-    readonly Error_QuorumError_MissingMembershipProof: "Error_QuorumError_MissingMembershipProof";
-    readonly Error_QuorumError_AliasAlreadyTaken: "Error_QuorumError_AliasAlreadyTaken";
-    readonly Error_QuorumError_AliasNotFound: "Error_QuorumError_AliasNotFound";
-    readonly Error_QuorumError_AliasInactive: "Error_QuorumError_AliasInactive";
-    readonly Error_QuorumError_IdentitySealingFailed: "Error_QuorumError_IdentitySealingFailed";
-    readonly Error_QuorumError_ShardVerificationFailed: "Error_QuorumError_ShardVerificationFailed";
-    readonly Error_QuorumError_QuorumDatabaseUnavailable: "Error_QuorumError_QuorumDatabaseUnavailable";
-    readonly Error_QuorumError_TransactionFailed: "Error_QuorumError_TransactionFailed";
-    readonly Error_QuorumError_AuditChainCorrupted: "Error_QuorumError_AuditChainCorrupted";
+    readonly Error_BrightTrustError_InvalidBrightTrustId: "Error_BrightTrustError_InvalidBrightTrustId";
+    readonly Error_BrightTrustError_DocumentNotFound: "Error_BrightTrustError_DocumentNotFound";
+    readonly Error_BrightTrustError_UnableToRestoreDocument: "Error_BrightTrustError_UnableToRestoreDocument";
+    readonly Error_BrightTrustError_NotImplemented: "Error_BrightTrustError_NotImplemented";
+    readonly Error_BrightTrustError_Uninitialized: "Error_BrightTrustError_Uninitialized";
+    readonly Error_BrightTrustError_MemberNotFound: "Error_BrightTrustError_MemberNotFound";
+    readonly Error_BrightTrustError_NotEnoughMembers: "Error_BrightTrustError_NotEnoughMembers";
+    readonly Error_BrightTrustError_TransitionInProgress: "Error_BrightTrustError_TransitionInProgress";
+    readonly Error_BrightTrustError_InvalidModeTransition: "Error_BrightTrustError_InvalidModeTransition";
+    readonly Error_BrightTrustError_InsufficientMembersForTransition: "Error_BrightTrustError_InsufficientMembersForTransition";
+    readonly Error_BrightTrustError_MemberAlreadyExists: "Error_BrightTrustError_MemberAlreadyExists";
+    readonly Error_BrightTrustError_InsufficientRemainingMembers: "Error_BrightTrustError_InsufficientRemainingMembers";
+    readonly Error_BrightTrustError_MemberBanned: "Error_BrightTrustError_MemberBanned";
+    readonly Error_BrightTrustError_MemberSuspended: "Error_BrightTrustError_MemberSuspended";
+    readonly Error_BrightTrustError_DuplicateProposal: "Error_BrightTrustError_DuplicateProposal";
+    readonly Error_BrightTrustError_ProposalExpired: "Error_BrightTrustError_ProposalExpired";
+    readonly Error_BrightTrustError_DuplicateVote: "Error_BrightTrustError_DuplicateVote";
+    readonly Error_BrightTrustError_VoterNotOnProposal: "Error_BrightTrustError_VoterNotOnProposal";
+    readonly Error_BrightTrustError_AuthenticationFailed: "Error_BrightTrustError_AuthenticationFailed";
+    readonly Error_BrightTrustError_VotingLocked: "Error_BrightTrustError_VotingLocked";
+    readonly Error_BrightTrustError_MissingAttachment: "Error_BrightTrustError_MissingAttachment";
+    readonly Error_BrightTrustError_AttachmentNotRetrievable: "Error_BrightTrustError_AttachmentNotRetrievable";
+    readonly Error_BrightTrustError_CannotBanSelf: "Error_BrightTrustError_CannotBanSelf";
+    readonly Error_BrightTrustError_MemberAlreadyBanned: "Error_BrightTrustError_MemberAlreadyBanned";
+    readonly Error_BrightTrustError_MemberNotBanned: "Error_BrightTrustError_MemberNotBanned";
+    readonly Error_BrightTrustError_NewMemberCannotProposeBan: "Error_BrightTrustError_NewMemberCannotProposeBan";
+    readonly Error_BrightTrustError_BanCoolingPeriodNotElapsed: "Error_BrightTrustError_BanCoolingPeriodNotElapsed";
+    readonly Error_BrightTrustError_InvalidBanRecordSignatures: "Error_BrightTrustError_InvalidBanRecordSignatures";
+    readonly Error_BrightTrustError_RedistributionFailed: "Error_BrightTrustError_RedistributionFailed";
+    readonly Error_BrightTrustError_InsufficientSharesForReconstruction: "Error_BrightTrustError_InsufficientSharesForReconstruction";
+    readonly Error_BrightTrustError_KeyReconstructionValidationFailed: "Error_BrightTrustError_KeyReconstructionValidationFailed";
+    readonly Error_BrightTrustError_IdentityPermanentlyUnrecoverable: "Error_BrightTrustError_IdentityPermanentlyUnrecoverable";
+    readonly Error_BrightTrustError_InvalidMembershipProof: "Error_BrightTrustError_InvalidMembershipProof";
+    readonly Error_BrightTrustError_MissingMembershipProof: "Error_BrightTrustError_MissingMembershipProof";
+    readonly Error_BrightTrustError_AliasAlreadyTaken: "Error_BrightTrustError_AliasAlreadyTaken";
+    readonly Error_BrightTrustError_AliasNotFound: "Error_BrightTrustError_AliasNotFound";
+    readonly Error_BrightTrustError_AliasInactive: "Error_BrightTrustError_AliasInactive";
+    readonly Error_BrightTrustError_IdentitySealingFailed: "Error_BrightTrustError_IdentitySealingFailed";
+    readonly Error_BrightTrustError_ShardVerificationFailed: "Error_BrightTrustError_ShardVerificationFailed";
+    readonly Error_BrightTrustError_BrightTrustDatabaseUnavailable: "Error_BrightTrustError_BrightTrustDatabaseUnavailable";
+    readonly Error_BrightTrustError_TransactionFailed: "Error_BrightTrustError_TransactionFailed";
+    readonly Error_BrightTrustError_AuditChainCorrupted: "Error_BrightTrustError_AuditChainCorrupted";
     readonly Error_IdentityValidationError_InvalidSignature: "Error_IdentityValidationError_InvalidSignature";
     readonly Error_IdentityValidationError_UnregisteredAlias: "Error_IdentityValidationError_UnregisteredAlias";
     readonly Error_IdentityValidationError_InactiveAlias: "Error_IdentityValidationError_InactiveAlias";
@@ -461,19 +467,19 @@ export declare const BrightChainStrings: import("@digitaldefiance/i18n-lib").Bra
     readonly Error_MemberDocument_Hint: "Error_MemberDocument_Hint";
     readonly Error_MemberDocument_CBLNotGenerated: "Error_MemberDocument_CBLNotGenerated";
     readonly Error_MemberProfileDocument_Hint: "Error_MemberProfileDocument_Hint";
-    readonly Error_QuorumDocument_CreatorMustBeSetBeforeSaving: "Error_QuorumDocument_CreatorMustBeSetBeforeSaving";
-    readonly Error_QuorumDocument_CreatorMustBeSetBeforeEncrypting: "Error_QuorumDocument_CreatorMustBeSetBeforeEncrypting";
-    readonly Error_QuorumDocument_DocumentHasNoEncryptedData: "Error_QuorumDocument_DocumentHasNoEncryptedData";
-    readonly Error_QuorumDocument_InvalidEncryptedDataFormat: "Error_QuorumDocument_InvalidEncryptedDataFormat";
-    readonly Error_QuorumDocument_InvalidMemberIdsFormat: "Error_QuorumDocument_InvalidMemberIdsFormat";
-    readonly Error_QuorumDocument_InvalidSignatureFormat: "Error_QuorumDocument_InvalidSignatureFormat";
-    readonly Error_QuorumDocument_InvalidCreatorIdFormat: "Error_QuorumDocument_InvalidCreatorIdFormat";
-    readonly Error_QuorumDocument_InvalidChecksumFormat: "Error_QuorumDocument_InvalidChecksumFormat";
-    readonly QuorumDataRecord_MustShareWithAtLeastTwoMembers: "QuorumDataRecord_MustShareWithAtLeastTwoMembers";
-    readonly QuorumDataRecord_SharesRequiredExceedsMembers: "QuorumDataRecord_SharesRequiredExceedsMembers";
-    readonly QuorumDataRecord_SharesRequiredMustBeAtLeastTwo: "QuorumDataRecord_SharesRequiredMustBeAtLeastTwo";
-    readonly QuorumDataRecord_InvalidChecksum: "QuorumDataRecord_InvalidChecksum";
-    readonly QuorumDataRecord_InvalidSignature: "QuorumDataRecord_InvalidSignature";
+    readonly Error_BrightTrustDocument_CreatorMustBeSetBeforeSaving: "Error_BrightTrustDocument_CreatorMustBeSetBeforeSaving";
+    readonly Error_BrightTrustDocument_CreatorMustBeSetBeforeEncrypting: "Error_BrightTrustDocument_CreatorMustBeSetBeforeEncrypting";
+    readonly Error_BrightTrustDocument_DocumentHasNoEncryptedData: "Error_BrightTrustDocument_DocumentHasNoEncryptedData";
+    readonly Error_BrightTrustDocument_InvalidEncryptedDataFormat: "Error_BrightTrustDocument_InvalidEncryptedDataFormat";
+    readonly Error_BrightTrustDocument_InvalidMemberIdsFormat: "Error_BrightTrustDocument_InvalidMemberIdsFormat";
+    readonly Error_BrightTrustDocument_InvalidSignatureFormat: "Error_BrightTrustDocument_InvalidSignatureFormat";
+    readonly Error_BrightTrustDocument_InvalidCreatorIdFormat: "Error_BrightTrustDocument_InvalidCreatorIdFormat";
+    readonly Error_BrightTrustDocument_InvalidChecksumFormat: "Error_BrightTrustDocument_InvalidChecksumFormat";
+    readonly BrightTrustDataRecord_MustShareWithAtLeastTwoMembers: "BrightTrustDataRecord_MustShareWithAtLeastTwoMembers";
+    readonly BrightTrustDataRecord_SharesRequiredExceedsMembers: "BrightTrustDataRecord_SharesRequiredExceedsMembers";
+    readonly BrightTrustDataRecord_SharesRequiredMustBeAtLeastTwo: "BrightTrustDataRecord_SharesRequiredMustBeAtLeastTwo";
+    readonly BrightTrustDataRecord_InvalidChecksum: "BrightTrustDataRecord_InvalidChecksum";
+    readonly BrightTrustDataRecord_InvalidSignature: "BrightTrustDataRecord_InvalidSignature";
     readonly BlockLogger_Redacted: "BlockLogger_Redacted";
     readonly Error_MemberSchema_InvalidIdFormat: "Error_MemberSchema_InvalidIdFormat";
     readonly Error_MemberSchema_InvalidPublicKeyFormat: "Error_MemberSchema_InvalidPublicKeyFormat";
@@ -666,7 +672,194 @@ export declare const BrightChainStrings: import("@digitaldefiance/i18n-lib").Bra
     readonly Dashboard_FailedToLoadBalance: "Dashboard_FailedToLoadBalance";
     readonly Dashboard_FailedToLoadReputation: "Dashboard_FailedToLoadReputation";
     readonly Dashboard_FailedToLoadData: "Dashboard_FailedToLoadData";
-}>;
+    readonly Admin_Dashboard_Title: "Admin_Dashboard_Title";
+    readonly Admin_Dashboard_AccessDenied: "Admin_Dashboard_AccessDenied";
+    readonly Admin_Dashboard_AccessDeniedDescription: "Admin_Dashboard_AccessDeniedDescription";
+    readonly Admin_Dashboard_Loading: "Admin_Dashboard_Loading";
+    readonly Admin_Dashboard_NoData: "Admin_Dashboard_NoData";
+    readonly Admin_Dashboard_RefreshNow: "Admin_Dashboard_RefreshNow";
+    readonly Admin_Dashboard_ErrorLastSuccessTemplate: "Admin_Dashboard_ErrorLastSuccessTemplate";
+    readonly Admin_Dashboard_ErrorLastSuccessNever: "Admin_Dashboard_ErrorLastSuccessNever";
+    readonly Admin_Dashboard_ServerIdentity: "Admin_Dashboard_ServerIdentity";
+    readonly Admin_Dashboard_Hostname: "Admin_Dashboard_Hostname";
+    readonly Admin_Dashboard_LocalNodeId: "Admin_Dashboard_LocalNodeId";
+    readonly Admin_Dashboard_Timestamp: "Admin_Dashboard_Timestamp";
+    readonly Admin_Dashboard_NA: "Admin_Dashboard_NA";
+    readonly Admin_Dashboard_Nodes: "Admin_Dashboard_Nodes";
+    readonly Admin_Dashboard_NoNodesRegistered: "Admin_Dashboard_NoNodesRegistered";
+    readonly Admin_Dashboard_DisconnectedPeers: "Admin_Dashboard_DisconnectedPeers";
+    readonly Admin_Dashboard_LumenClients: "Admin_Dashboard_LumenClients";
+    readonly Admin_Dashboard_ConnectedClients: "Admin_Dashboard_ConnectedClients";
+    readonly Admin_Dashboard_RoomsTemplate: "Admin_Dashboard_RoomsTemplate";
+    readonly Admin_Dashboard_NodeConnections: "Admin_Dashboard_NodeConnections";
+    readonly Admin_Dashboard_NodeToNodeConnections: "Admin_Dashboard_NodeToNodeConnections";
+    readonly Admin_Dashboard_SystemMetrics: "Admin_Dashboard_SystemMetrics";
+    readonly Admin_Dashboard_HeapUsed: "Admin_Dashboard_HeapUsed";
+    readonly Admin_Dashboard_HeapTotal: "Admin_Dashboard_HeapTotal";
+    readonly Admin_Dashboard_RSS: "Admin_Dashboard_RSS";
+    readonly Admin_Dashboard_External: "Admin_Dashboard_External";
+    readonly Admin_Dashboard_UptimeTemplate: "Admin_Dashboard_UptimeTemplate";
+    readonly Admin_Dashboard_NodeVersionTemplate: "Admin_Dashboard_NodeVersionTemplate";
+    readonly Admin_Dashboard_DBStats: "Admin_Dashboard_DBStats";
+    readonly Admin_Dashboard_Users: "Admin_Dashboard_Users";
+    readonly Admin_Dashboard_Roles: "Admin_Dashboard_Roles";
+    readonly Admin_Dashboard_Active: "Admin_Dashboard_Active";
+    readonly Admin_Dashboard_Locked: "Admin_Dashboard_Locked";
+    readonly Admin_Dashboard_Pending: "Admin_Dashboard_Pending";
+    readonly Admin_Dashboard_Members: "Admin_Dashboard_Members";
+    readonly Admin_Dashboard_Threshold: "Admin_Dashboard_Threshold";
+    readonly Admin_Dashboard_Pools: "Admin_Dashboard_Pools";
+    readonly Admin_Dashboard_NoPools: "Admin_Dashboard_NoPools";
+    readonly Admin_Dashboard_Dependencies: "Admin_Dashboard_Dependencies";
+    readonly Admin_Dashboard_BlockStore: "Admin_Dashboard_BlockStore";
+    readonly Admin_Dashboard_TotalBlocks: "Admin_Dashboard_TotalBlocks";
+    readonly Admin_Dashboard_TotalSize: "Admin_Dashboard_TotalSize";
+    readonly Admin_Dashboard_TotalPosts: "Admin_Dashboard_TotalPosts";
+    readonly Admin_Dashboard_ActiveUsersLast30Days: "Admin_Dashboard_ActiveUsersLast30Days";
+    readonly Admin_Dashboard_Conversations: "Admin_Dashboard_Conversations";
+    readonly Admin_Dashboard_Messages: "Admin_Dashboard_Messages";
+    readonly Admin_Dashboard_TotalVaults: "Admin_Dashboard_TotalVaults";
+    readonly Admin_Dashboard_SharedVaults: "Admin_Dashboard_SharedVaults";
+    readonly Admin_Dashboard_TotalEmails: "Admin_Dashboard_TotalEmails";
+    readonly Admin_Dashboard_DeliveryFailures: "Admin_Dashboard_DeliveryFailures";
+    readonly Admin_Dashboard_Last24Hours: "Admin_Dashboard_Last24Hours";
+    readonly Admin_Menu_Dashboard: "Admin_Menu_Dashboard";
+    readonly Admin_Menu_Users: "Admin_Menu_Users";
+    readonly Admin_Menu_Blocks: "Admin_Menu_Blocks";
+    readonly Admin_Menu_Chat: "Admin_Menu_Chat";
+    readonly Admin_Menu_Hub: "Admin_Menu_Hub";
+    readonly Admin_Menu_Mail: "Admin_Menu_Mail";
+    readonly Admin_Menu_Pass: "Admin_Menu_Pass";
+    readonly Admin_Common_Loading: "Admin_Common_Loading";
+    readonly Admin_Common_Previous: "Admin_Common_Previous";
+    readonly Admin_Common_Next: "Admin_Common_Next";
+    readonly Admin_Common_PageTemplate: "Admin_Common_PageTemplate";
+    readonly Admin_Common_Cancel: "Admin_Common_Cancel";
+    readonly Admin_Common_Delete: "Admin_Common_Delete";
+    readonly Admin_Common_Yes: "Admin_Common_Yes";
+    readonly Admin_Common_No: "Admin_Common_No";
+    readonly Admin_Common_Never: "Admin_Common_Never";
+    readonly Admin_Common_Close: "Admin_Common_Close";
+    readonly Admin_Users_Title: "Admin_Users_Title";
+    readonly Admin_Users_FilterAll: "Admin_Users_FilterAll";
+    readonly Admin_Users_FilterActive: "Admin_Users_FilterActive";
+    readonly Admin_Users_FilterLocked: "Admin_Users_FilterLocked";
+    readonly Admin_Users_FilterPending: "Admin_Users_FilterPending";
+    readonly Admin_Users_ColUsername: "Admin_Users_ColUsername";
+    readonly Admin_Users_ColEmail: "Admin_Users_ColEmail";
+    readonly Admin_Users_ColStatus: "Admin_Users_ColStatus";
+    readonly Admin_Users_ColEmailVerified: "Admin_Users_ColEmailVerified";
+    readonly Admin_Users_ColLastLogin: "Admin_Users_ColLastLogin";
+    readonly Admin_Users_ColActions: "Admin_Users_ColActions";
+    readonly Admin_Users_NoUsersFound: "Admin_Users_NoUsersFound";
+    readonly Admin_Users_UnlockUser: "Admin_Users_UnlockUser";
+    readonly Admin_Users_LockUser: "Admin_Users_LockUser";
+    readonly Admin_Users_LockUserTitle: "Admin_Users_LockUserTitle";
+    readonly Admin_Users_UnlockUserTitle: "Admin_Users_UnlockUserTitle";
+    readonly Admin_Users_LockConfirmTemplate: "Admin_Users_LockConfirmTemplate";
+    readonly Admin_Users_UnlockConfirmTemplate: "Admin_Users_UnlockConfirmTemplate";
+    readonly Admin_Users_LockWarning: "Admin_Users_LockWarning";
+    readonly Admin_Users_ColRole: "Admin_Users_ColRole";
+    readonly Admin_Users_ChangeRole: "Admin_Users_ChangeRole";
+    readonly Admin_Users_ChangeRoleTitle: "Admin_Users_ChangeRoleTitle";
+    readonly Admin_Users_ChangeRoleConfirmTemplate: "Admin_Users_ChangeRoleConfirmTemplate";
+    readonly Admin_Users_ChangeRoleWarning: "Admin_Users_ChangeRoleWarning";
+    readonly Admin_Users_RoleAdmin: "Admin_Users_RoleAdmin";
+    readonly Admin_Users_RoleMember: "Admin_Users_RoleMember";
+    readonly Admin_Users_RoleSystem: "Admin_Users_RoleSystem";
+    readonly Admin_Users_CannotChangeOwnRole: "Admin_Users_CannotChangeOwnRole";
+    readonly Admin_Users_CannotChangeSystemUser: "Admin_Users_CannotChangeSystemUser";
+    readonly Admin_Users_DeleteUser: "Admin_Users_DeleteUser";
+    readonly Admin_Users_DeleteUserTitle: "Admin_Users_DeleteUserTitle";
+    readonly Admin_Users_DeleteConfirmTemplate: "Admin_Users_DeleteConfirmTemplate";
+    readonly Admin_Users_DeleteWarning: "Admin_Users_DeleteWarning";
+    readonly Admin_Users_CannotDeleteSelf: "Admin_Users_CannotDeleteSelf";
+    readonly Admin_Users_CannotDeleteSystemUser: "Admin_Users_CannotDeleteSystemUser";
+    readonly Admin_Blocks_Title: "Admin_Blocks_Title";
+    readonly Admin_Blocks_SearchPlaceholder: "Admin_Blocks_SearchPlaceholder";
+    readonly Admin_Blocks_FilterAllDurability: "Admin_Blocks_FilterAllDurability";
+    readonly Admin_Blocks_FilterStandard: "Admin_Blocks_FilterStandard";
+    readonly Admin_Blocks_FilterHighDurability: "Admin_Blocks_FilterHighDurability";
+    readonly Admin_Blocks_FilterEphemeral: "Admin_Blocks_FilterEphemeral";
+    readonly Admin_Blocks_SortByDate: "Admin_Blocks_SortByDate";
+    readonly Admin_Blocks_SortBySize: "Admin_Blocks_SortBySize";
+    readonly Admin_Blocks_Detail: "Admin_Blocks_Detail";
+    readonly Admin_Blocks_ColBlockId: "Admin_Blocks_ColBlockId";
+    readonly Admin_Blocks_ColSize: "Admin_Blocks_ColSize";
+    readonly Admin_Blocks_ColDurability: "Admin_Blocks_ColDurability";
+    readonly Admin_Blocks_ColCreated: "Admin_Blocks_ColCreated";
+    readonly Admin_Blocks_ColAccessCount: "Admin_Blocks_ColAccessCount";
+    readonly Admin_Blocks_ColReplication: "Admin_Blocks_ColReplication";
+    readonly Admin_Blocks_ColActions: "Admin_Blocks_ColActions";
+    readonly Admin_Blocks_NoBlocksFound: "Admin_Blocks_NoBlocksFound";
+    readonly Admin_Blocks_DiscoverNodes: "Admin_Blocks_DiscoverNodes";
+    readonly Admin_Blocks_NodesHoldingBlockTemplate: "Admin_Blocks_NodesHoldingBlockTemplate";
+    readonly Admin_Blocks_NoNodesFound: "Admin_Blocks_NoNodesFound";
+    readonly Admin_Blocks_Checksum: "Admin_Blocks_Checksum";
+    readonly Admin_Blocks_DeleteTitle: "Admin_Blocks_DeleteTitle";
+    readonly Admin_Blocks_DeleteConfirmTemplate: "Admin_Blocks_DeleteConfirmTemplate";
+    readonly Admin_Blocks_SizeBytesTemplate: "Admin_Blocks_SizeBytesTemplate";
+    readonly Admin_Pass_Title: "Admin_Pass_Title";
+    readonly Admin_Pass_EncryptedNotice: "Admin_Pass_EncryptedNotice";
+    readonly Admin_Pass_ColOwner: "Admin_Pass_ColOwner";
+    readonly Admin_Pass_ColShared: "Admin_Pass_ColShared";
+    readonly Admin_Pass_ColCreated: "Admin_Pass_ColCreated";
+    readonly Admin_Pass_ColLastAccessed: "Admin_Pass_ColLastAccessed";
+    readonly Admin_Pass_ColActions: "Admin_Pass_ColActions";
+    readonly Admin_Pass_NoVaultsFound: "Admin_Pass_NoVaultsFound";
+    readonly Admin_Pass_DeleteVault: "Admin_Pass_DeleteVault";
+    readonly Admin_Pass_DeleteVaultTitle: "Admin_Pass_DeleteVaultTitle";
+    readonly Admin_Pass_DeleteVaultConfirm: "Admin_Pass_DeleteVaultConfirm";
+    readonly Admin_Chat_Title: "Admin_Chat_Title";
+    readonly Admin_Chat_ColId: "Admin_Chat_ColId";
+    readonly Admin_Chat_ColParticipants: "Admin_Chat_ColParticipants";
+    readonly Admin_Chat_ColMessages: "Admin_Chat_ColMessages";
+    readonly Admin_Chat_ColLastActivity: "Admin_Chat_ColLastActivity";
+    readonly Admin_Chat_NoConversationsFound: "Admin_Chat_NoConversationsFound";
+    readonly Admin_Chat_MessagesForTemplate: "Admin_Chat_MessagesForTemplate";
+    readonly Admin_Chat_LoadingMessages: "Admin_Chat_LoadingMessages";
+    readonly Admin_Chat_NoMessages: "Admin_Chat_NoMessages";
+    readonly Admin_Chat_ColSender: "Admin_Chat_ColSender";
+    readonly Admin_Chat_ColContent: "Admin_Chat_ColContent";
+    readonly Admin_Chat_ColCreated: "Admin_Chat_ColCreated";
+    readonly Admin_Chat_ColStatus: "Admin_Chat_ColStatus";
+    readonly Admin_Chat_StatusDeleted: "Admin_Chat_StatusDeleted";
+    readonly Admin_Chat_StatusActive: "Admin_Chat_StatusActive";
+    readonly Admin_Chat_DeleteMessage: "Admin_Chat_DeleteMessage";
+    readonly Admin_Chat_DeleteMessageTitle: "Admin_Chat_DeleteMessageTitle";
+    readonly Admin_Chat_DeleteMessageConfirm: "Admin_Chat_DeleteMessageConfirm";
+    readonly Admin_Hub_Title: "Admin_Hub_Title";
+    readonly Admin_Hub_FilterByAuthorId: "Admin_Hub_FilterByAuthorId";
+    readonly Admin_Hub_FilterAllPosts: "Admin_Hub_FilterAllPosts";
+    readonly Admin_Hub_FilterActive: "Admin_Hub_FilterActive";
+    readonly Admin_Hub_FilterDeleted: "Admin_Hub_FilterDeleted";
+    readonly Admin_Hub_ColAuthor: "Admin_Hub_ColAuthor";
+    readonly Admin_Hub_ColContentPreview: "Admin_Hub_ColContentPreview";
+    readonly Admin_Hub_ColCreated: "Admin_Hub_ColCreated";
+    readonly Admin_Hub_ColStatus: "Admin_Hub_ColStatus";
+    readonly Admin_Hub_ColLikes: "Admin_Hub_ColLikes";
+    readonly Admin_Hub_ColReposts: "Admin_Hub_ColReposts";
+    readonly Admin_Hub_ColActions: "Admin_Hub_ColActions";
+    readonly Admin_Hub_StatusDeleted: "Admin_Hub_StatusDeleted";
+    readonly Admin_Hub_StatusActive: "Admin_Hub_StatusActive";
+    readonly Admin_Hub_NoPostsFound: "Admin_Hub_NoPostsFound";
+    readonly Admin_Hub_SoftDeletePost: "Admin_Hub_SoftDeletePost";
+    readonly Admin_Hub_DeletePostTitle: "Admin_Hub_DeletePostTitle";
+    readonly Admin_Hub_DeletePostConfirm: "Admin_Hub_DeletePostConfirm";
+    readonly Admin_Mail_Title: "Admin_Mail_Title";
+    readonly Admin_Mail_ColSender: "Admin_Mail_ColSender";
+    readonly Admin_Mail_ColRecipients: "Admin_Mail_ColRecipients";
+    readonly Admin_Mail_ColSubject: "Admin_Mail_ColSubject";
+    readonly Admin_Mail_ColCreated: "Admin_Mail_ColCreated";
+    readonly Admin_Mail_ColDeliveryStatus: "Admin_Mail_ColDeliveryStatus";
+    readonly Admin_Mail_ColActions: "Admin_Mail_ColActions";
+    readonly Admin_Mail_NoEmailsFound: "Admin_Mail_NoEmailsFound";
+    readonly Admin_Mail_DeleteEmail: "Admin_Mail_DeleteEmail";
+    readonly Admin_Mail_DeleteEmailTitle: "Admin_Mail_DeleteEmailTitle";
+    readonly Admin_Mail_DeleteEmailConfirm: "Admin_Mail_DeleteEmailConfirm";
+};
+export declare const BrightChainStrings: BrandedStringKeys<typeof _brightChainKeys>;
 export type BrightChainStringKey = BrandedStringKeyValue<typeof BrightChainStrings>;
 export type BrightChainStringKeyValue = BrightChainStringKey;
+export {};
 //# sourceMappingURL=brightChainStrings.d.ts.map

package/src/lib/enumerations/brightChainStrings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brightChainStrings.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/brightChainStrings.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAGpD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAutCpB,CAAC;AAEZ,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,CACtD,OAAO,kBAAkB,CAC1B,CAAC;AAGF,MAAM,MAAM,yBAAyB,GAAG,oBAAoB,CAAC"}
+{"version":3,"file":"brightChainStrings.d.ts","sourceRoot":"","sources":["../../../../../brightchain-lib/src/lib/enumerations/brightChainStrings.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AAEnC,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAGpD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA87CZ,CAAC;AAEX,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,OAAO,gBAAgB,CACV,CAAC;AAEjE,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,CACtD,OAAO,kBAAkB,CAC1B,CAAC;AAGF,MAAM,MAAM,yBAAyB,GAAG,oBAAoB,CAAC"}