bitbadgesjs-sdk 0.3.94 → 0.3.95

package/dist/esm/core/permissions.js

@@ -0,0 +1,956 @@
+import { BaseNumberTypeClass, convertClassPropertiesAndMaintainNumberTypes, deepCopyPrimitives } from '@/common/base';
+import * as badges from '@/proto/badges';
+import { AddressList } from './addressLists';
+import { GetFirstMatchOnly, getOverlapsAndNonOverlaps, universalRemoveOverlaps } from './overlaps';
+import { BigIntify, Stringify } from '../common/string-numbers';
+import { UintRange, UintRangeArray } from './uintRanges';
+import { AllDefaultValues } from './validate-utils';
+export class UserPermissions extends BaseNumberTypeClass {
+    canUpdateOutgoingApprovals;
+    canUpdateIncomingApprovals;
+    canUpdateAutoApproveSelfInitiatedOutgoingTransfers;
+    canUpdateAutoApproveSelfInitiatedIncomingTransfers;
+    constructor(msg) {
+        super();
+        this.canUpdateOutgoingApprovals = msg.canUpdateOutgoingApprovals.map((x) => new UserOutgoingApprovalPermission(x));
+        this.canUpdateIncomingApprovals = msg.canUpdateIncomingApprovals.map((x) => new UserIncomingApprovalPermission(x));
+        this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers = msg.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((x) => new ActionPermission(x));
+        this.canUpdateAutoApproveSelfInitiatedIncomingTransfers = msg.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((x) => new ActionPermission(x));
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    toProto() {
+        return new badges.UserPermissions(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserPermissions.fromProto(badges.UserPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserPermissions.fromProto(badges.UserPermissions.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new UserPermissions({
+            canUpdateOutgoingApprovals: protoMsg.canUpdateOutgoingApprovals.map((x) => UserOutgoingApprovalPermission.fromProto(x, convertFunction)),
+            canUpdateIncomingApprovals: protoMsg.canUpdateIncomingApprovals.map((x) => UserIncomingApprovalPermission.fromProto(x, convertFunction)),
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((x) => ActionPermission.fromProto(x, convertFunction)),
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((x) => ActionPermission.fromProto(x, convertFunction))
+        });
+    }
+    static validateUpdate(oldPermissions, newPermissions) {
+        const responses = [
+            UserOutgoingApprovalPermission.validateUpdate(oldPermissions.canUpdateOutgoingApprovals, newPermissions.canUpdateOutgoingApprovals),
+            UserIncomingApprovalPermission.validateUpdate(oldPermissions.canUpdateIncomingApprovals, newPermissions.canUpdateIncomingApprovals),
+            ActionPermission.validateUpdate(oldPermissions.canUpdateAutoApproveSelfInitiatedOutgoingTransfers, newPermissions.canUpdateAutoApproveSelfInitiatedOutgoingTransfers),
+            ActionPermission.validateUpdate(oldPermissions.canUpdateAutoApproveSelfInitiatedIncomingTransfers, newPermissions.canUpdateAutoApproveSelfInitiatedIncomingTransfers)
+        ];
+        return responses.find((x) => x !== null) ?? null;
+    }
+    static InitEmpty() {
+        return new UserPermissions({
+            canUpdateOutgoingApprovals: [],
+            canUpdateIncomingApprovals: [],
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [],
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: []
+        });
+    }
+}
+export class UserOutgoingApprovalPermission extends BaseNumberTypeClass {
+    toListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.toListId = msg.toListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.transferTimes = UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    toProto() {
+        return new badges.UserOutgoingApprovalPermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserOutgoingApprovalPermission.fromProto(badges.UserOutgoingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserOutgoingApprovalPermission.fromProto(badges.UserOutgoingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new UserOutgoingApprovalPermission({
+            toListId: protoMsg.toListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermission({
+            ...this,
+            fromList: getReservedAddressList(address),
+            fromListId: address
+        });
+    }
+    static validateUpdate(permissions, newPermission) {
+        const dummyAddress = '0x';
+        const castedPermissions = permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const dummyAddress = '0x';
+        return CollectionApprovalPermission.check(details, permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress)), time);
+    }
+}
+export class UserIncomingApprovalPermission extends BaseNumberTypeClass {
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.approvalId = msg.approvalId;
+        this.transferTimes = UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    toProto() {
+        return new badges.UserIncomingApprovalPermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return UserIncomingApprovalPermission.fromProto(badges.UserIncomingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return UserIncomingApprovalPermission.fromProto(badges.UserIncomingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new UserIncomingApprovalPermission({
+            fromListId: protoMsg.fromListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermission({
+            ...this,
+            toList: getReservedAddressList(address),
+            toListId: address
+        });
+    }
+    static validateUpdate(permissions, newPermission) {
+        const dummyAddress = '0x';
+        const castedPermissions = permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToCollectionApprovalPermission(dummyAddress).castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const dummyAddress = '0x';
+        return CollectionApprovalPermission.check(details, permissions.map((x) => x.castToCollectionApprovalPermission(dummyAddress)), time);
+    }
+}
+export class CollectionPermissions extends BaseNumberTypeClass {
+    canDeleteCollection;
+    canArchiveCollection;
+    canUpdateOffChainBalancesMetadata;
+    canUpdateStandards;
+    canUpdateCustomData;
+    canUpdateManager;
+    canUpdateCollectionMetadata;
+    canCreateMoreBadges;
+    canUpdateBadgeMetadata;
+    canUpdateCollectionApprovals;
+    constructor(msg) {
+        super();
+        this.canDeleteCollection = msg.canDeleteCollection.map((x) => new ActionPermission(x));
+        this.canArchiveCollection = msg.canArchiveCollection.map((x) => new TimedUpdatePermission(x));
+        this.canUpdateOffChainBalancesMetadata = msg.canUpdateOffChainBalancesMetadata.map((x) => new TimedUpdatePermission(x));
+        this.canUpdateStandards = msg.canUpdateStandards.map((x) => new TimedUpdatePermission(x));
+        this.canUpdateCustomData = msg.canUpdateCustomData.map((x) => new TimedUpdatePermission(x));
+        this.canUpdateManager = msg.canUpdateManager.map((x) => new TimedUpdatePermission(x));
+        this.canUpdateCollectionMetadata = msg.canUpdateCollectionMetadata.map((x) => new TimedUpdatePermission(x));
+        this.canCreateMoreBadges = msg.canCreateMoreBadges.map((x) => new BalancesActionPermission(x));
+        this.canUpdateBadgeMetadata = msg.canUpdateBadgeMetadata.map((x) => new TimedUpdateWithBadgeIdsPermission(x));
+        this.canUpdateCollectionApprovals = msg.canUpdateCollectionApprovals.map((x) => new CollectionApprovalPermission(x));
+    }
+    convert(convertFunction) {
+        return new CollectionPermissions(deepCopyPrimitives({
+            canDeleteCollection: this.canDeleteCollection.map((x) => x.convert(convertFunction)),
+            canArchiveCollection: this.canArchiveCollection.map((x) => x.convert(convertFunction)),
+            canUpdateOffChainBalancesMetadata: this.canUpdateOffChainBalancesMetadata.map((x) => x.convert(convertFunction)),
+            canUpdateStandards: this.canUpdateStandards.map((x) => x.convert(convertFunction)),
+            canUpdateCustomData: this.canUpdateCustomData.map((x) => x.convert(convertFunction)),
+            canUpdateManager: this.canUpdateManager.map((x) => x.convert(convertFunction)),
+            canUpdateCollectionMetadata: this.canUpdateCollectionMetadata.map((x) => x.convert(convertFunction)),
+            canCreateMoreBadges: this.canCreateMoreBadges.map((x) => x.convert(convertFunction)),
+            canUpdateBadgeMetadata: this.canUpdateBadgeMetadata.map((x) => x.convert(convertFunction)),
+            canUpdateCollectionApprovals: this.canUpdateCollectionApprovals.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new badges.CollectionPermissions(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionPermissions.fromProto(badges.CollectionPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionPermissions.fromProto(badges.CollectionPermissions.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new CollectionPermissions({
+            canDeleteCollection: protoMsg.canDeleteCollection.map((x) => ActionPermission.fromProto(x, convertFunction)),
+            canArchiveCollection: protoMsg.canArchiveCollection.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateOffChainBalancesMetadata: protoMsg.canUpdateOffChainBalancesMetadata.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateStandards: protoMsg.canUpdateStandards.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateCustomData: protoMsg.canUpdateCustomData.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateManager: protoMsg.canUpdateManager.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canUpdateCollectionMetadata: protoMsg.canUpdateCollectionMetadata.map((x) => TimedUpdatePermission.fromProto(x, convertFunction)),
+            canCreateMoreBadges: protoMsg.canCreateMoreBadges.map((x) => BalancesActionPermission.fromProto(x, convertFunction)),
+            canUpdateBadgeMetadata: protoMsg.canUpdateBadgeMetadata.map((x) => TimedUpdateWithBadgeIdsPermission.fromProto(x, convertFunction)),
+            canUpdateCollectionApprovals: protoMsg.canUpdateCollectionApprovals.map((x) => CollectionApprovalPermission.fromProto(x, convertFunction))
+        });
+    }
+    static validateUpdate(oldPermissions, newPermissions) {
+        const responses = [
+            ActionPermission.validateUpdate(oldPermissions.canDeleteCollection, newPermissions.canDeleteCollection),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateManager, newPermissions.canUpdateManager),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateCustomData, newPermissions.canUpdateCustomData),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateStandards, newPermissions.canUpdateStandards),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canArchiveCollection, newPermissions.canArchiveCollection),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateOffChainBalancesMetadata, newPermissions.canUpdateOffChainBalancesMetadata),
+            TimedUpdatePermission.validateUpdate(oldPermissions.canUpdateCollectionMetadata, newPermissions.canUpdateCollectionMetadata),
+            BalancesActionPermission.validateUpdate(oldPermissions.canCreateMoreBadges, newPermissions.canCreateMoreBadges),
+            TimedUpdateWithBadgeIdsPermission.validateUpdate(oldPermissions.canUpdateBadgeMetadata, newPermissions.canUpdateBadgeMetadata),
+            CollectionApprovalPermission.validateUpdate(oldPermissions.canUpdateCollectionApprovals, newPermissions.canUpdateCollectionApprovals)
+        ];
+        return responses.find((x) => x !== null) ?? null;
+    }
+    static InitEmpty() {
+        return new CollectionPermissions({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateOffChainBalancesMetadata: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [],
+            canUpdateCollectionMetadata: [],
+            canCreateMoreBadges: [],
+            canUpdateBadgeMetadata: [],
+            canUpdateCollectionApprovals: []
+        });
+    }
+}
+export class ActionPermission extends BaseNumberTypeClass {
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new ActionPermission(deepCopyPrimitives({
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new badges.ActionPermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return ActionPermission.fromProto(badges.ActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return ActionPermission.fromProto(badges.ActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new ActionPermission({
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...AllDefaultValues,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify)
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(permissions, time) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        return checkUniversalPermissionPermits(castedPermissions, time);
+    }
+}
+function checkUniversalPermissionPermits(permissions, time) {
+    const permissionDetails = GetFirstMatchOnly(permissions);
+    for (const permissionDetail of permissionDetails) {
+        const err = checkNotForbidden(permissionDetail, time ? BigInt(time) : undefined);
+        if (err) {
+            return err;
+        }
+    }
+    return null;
+}
+export class TimedUpdatePermission extends BaseNumberTypeClass {
+    timelineTimes;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.timelineTimes = UintRangeArray.From(msg.timelineTimes);
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new TimedUpdatePermission(deepCopyPrimitives({
+            timelineTimes: this.timelineTimes.map((x) => x.convert(convertFunction)),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new badges.TimedUpdatePermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return TimedUpdatePermission.fromProto(badges.TimedUpdatePermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return TimedUpdatePermission.fromProto(badges.TimedUpdatePermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new TimedUpdatePermission({
+            timelineTimes: protoMsg.timelineTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...AllDefaultValues,
+            timelineTimes: this.timelineTimes.convert(BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify),
+            usesTimelineTimes: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(timelineTimes, permissions, time) {
+        const detailsToCheck = [];
+        for (const timelineTime of timelineTimes) {
+            detailsToCheck.push({
+                ...AllDefaultDetailsValues,
+                timelineTime: timelineTime.convert(BigIntify)
+            });
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = GetFirstMatchOnly(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+const AllDefaultDetailsValues = {
+    timelineTime: new UintRange({ start: -1n, end: -1n }),
+    badgeId: new UintRange({ start: -1n, end: -1n }),
+    ownershipTime: new UintRange({ start: -1n, end: -1n }),
+    transferTime: new UintRange({ start: -1n, end: -1n }),
+    toList: new AddressList({ listId: 'All', addresses: [], whitelist: false, uri: '', customData: '', createdBy: '' }),
+    fromList: new AddressList({ listId: 'All', addresses: [], whitelist: false, uri: '', customData: '', createdBy: '' }),
+    initiatedByList: new AddressList({
+        listId: 'All',
+        addresses: [],
+        whitelist: false,
+        uri: '',
+        customData: '',
+        createdBy: ''
+    }),
+    approvalIdList: new AddressList({
+        listId: 'All',
+        addresses: [],
+        whitelist: false,
+        uri: '',
+        customData: '',
+        createdBy: ''
+    }),
+    permanentlyPermittedTimes: UintRangeArray.From([]),
+    permanentlyForbiddenTimes: UintRangeArray.From([]),
+    arbitraryValue: undefined
+};
+export class BalancesActionPermission extends BaseNumberTypeClass {
+    badgeIds;
+    ownershipTimes;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.badgeIds = UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new BalancesActionPermission(deepCopyPrimitives({
+            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new badges.BalancesActionPermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return BalancesActionPermission.fromProto(badges.BalancesActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return BalancesActionPermission.fromProto(badges.BalancesActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new BalancesActionPermission({
+            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...AllDefaultValues,
+            badgeIds: this.badgeIds.convert(BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify),
+            usesBadgeIds: true,
+            usesOwnershipTimes: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const ownershipTime of detail.ownershipTimes) {
+                for (const badgeId of detail.badgeIds) {
+                    detailsToCheck.push({
+                        ...AllDefaultDetailsValues,
+                        ownershipTime: ownershipTime.convert(BigIntify),
+                        badgeId: badgeId.convert(BigIntify)
+                    });
+                }
+            }
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = GetFirstMatchOnly(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+export class TimedUpdateWithBadgeIdsPermission extends BaseNumberTypeClass {
+    timelineTimes;
+    badgeIds;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.timelineTimes = UintRangeArray.From(msg.timelineTimes);
+        this.badgeIds = UintRangeArray.From(msg.badgeIds);
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission(deepCopyPrimitives({
+            timelineTimes: this.timelineTimes.map((x) => x.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new badges.TimedUpdateWithBadgeIdsPermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return TimedUpdateWithBadgeIdsPermission.fromProto(badges.TimedUpdateWithBadgeIdsPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return TimedUpdateWithBadgeIdsPermission.fromProto(badges.TimedUpdateWithBadgeIdsPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission({
+            timelineTimes: protoMsg.timelineTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    castToUniversalPermission() {
+        return {
+            ...AllDefaultValues,
+            timelineTimes: this.timelineTimes.convert(BigIntify),
+            badgeIds: this.badgeIds.convert(BigIntify),
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify),
+            usesTimelineTimes: true,
+            usesBadgeIds: true
+        };
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const timelineTime of detail.timelineTimes) {
+                for (const badgeId of detail.badgeIds) {
+                    detailsToCheck.push({
+                        ...AllDefaultDetailsValues,
+                        timelineTime: timelineTime.convert(BigIntify),
+                        badgeId: badgeId.convert(BigIntify)
+                    });
+                }
+            }
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = GetFirstMatchOnly(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined);
+    }
+}
+export class CollectionApprovalPermission extends BaseNumberTypeClass {
+    fromListId;
+    toListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        this.toListId = msg.toListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.transferTimes = UintRangeArray.From(msg.transferTimes);
+        this.badgeIds = UintRangeArray.From(msg.badgeIds);
+        this.ownershipTimes = UintRangeArray.From(msg.ownershipTimes);
+        this.approvalId = msg.approvalId;
+        this.permanentlyPermittedTimes = UintRangeArray.From(msg.permanentlyPermittedTimes);
+        this.permanentlyForbiddenTimes = UintRangeArray.From(msg.permanentlyForbiddenTimes);
+    }
+    convert(convertFunction) {
+        return new CollectionApprovalPermission(deepCopyPrimitives({
+            fromListId: this.fromListId,
+            toListId: this.toListId,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes.map((x) => x.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((x) => x.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((x) => x.convert(convertFunction)),
+            approvalId: this.approvalId,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new badges.CollectionApprovalPermission(this.convert(Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return CollectionApprovalPermission.fromProto(badges.CollectionApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return CollectionApprovalPermission.fromProto(badges.CollectionApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static fromProto(protoMsg, convertFunction) {
+        return new CollectionApprovalPermission({
+            fromListId: protoMsg.fromListId,
+            toListId: protoMsg.toListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map((x) => UintRange.fromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map((x) => UintRange.fromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map((x) => UintRange.fromProto(x, convertFunction))
+        });
+    }
+    static validateUpdate(permissions, newPermission) {
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const castedNewPermissions = newPermission.map((x) => x.castToUniversalPermission());
+        return validateUniversalPermissionUpdate(GetFirstMatchOnly(castedPermissions), GetFirstMatchOnly(castedNewPermissions));
+    }
+    static check(details, permissions, time) {
+        const detailsToCheck = [];
+        for (const detail of details) {
+            for (const transferTime of detail.transferTimes) {
+                for (const badgeId of detail.badgeIds) {
+                    for (const ownershipTime of detail.ownershipTimes) {
+                        detailsToCheck.push({
+                            ...AllDefaultDetailsValues,
+                            transferTime: transferTime.convert(BigIntify),
+                            badgeId: badgeId.convert(BigIntify),
+                            ownershipTime: ownershipTime.convert(BigIntify),
+                            toList: detail.toList,
+                            fromList: detail.fromList,
+                            initiatedByList: detail.initiatedByList,
+                            approvalIdList: detail.approvalIdList,
+                        });
+                    }
+                }
+            }
+        }
+        const castedPermissions = permissions.map((x) => x.castToUniversalPermission());
+        const permissionDetails = GetFirstMatchOnly(castedPermissions);
+        return checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time ? BigInt(time) : undefined, true);
+    }
+}
+const { getReservedAddressList, getReservedTrackerList } = AddressList;
+export class CollectionApprovalPermissionWithDetails extends CollectionApprovalPermission {
+    toList;
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new AddressList(data.toList);
+        this.fromList = new AddressList(data.fromList);
+        this.initiatedByList = new AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    castToUniversalPermission() {
+        return {
+            ...AllDefaultValues,
+            toList: this.toList,
+            fromList: this.fromList,
+            initiatedByList: this.initiatedByList,
+            transferTimes: this.transferTimes.convert(BigIntify),
+            badgeIds: this.badgeIds.convert(BigIntify),
+            ownershipTimes: this.ownershipTimes.convert(BigIntify),
+            approvalIdList: getReservedTrackerList(this.approvalId),
+            usesApprovalIdList: true,
+            usesBadgeIds: true,
+            usesTransferTimes: true,
+            usesOwnershipTimes: true,
+            usesToList: true,
+            usesFromList: true,
+            usesInitiatedByList: true,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.convert(BigIntify),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.convert(BigIntify)
+        };
+    }
+}
+export class UserIncomingApprovalPermissionWithDetails extends UserIncomingApprovalPermission {
+    fromList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.fromList = new AddressList(data.fromList);
+        this.initiatedByList = new AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermissionWithDetails({
+            ...this,
+            toList: getReservedAddressList(address),
+            toListId: address
+        });
+    }
+}
+export class UserOutgoingApprovalPermissionWithDetails extends UserOutgoingApprovalPermission {
+    toList;
+    initiatedByList;
+    constructor(data) {
+        super(data);
+        this.toList = new AddressList(data.toList);
+        this.initiatedByList = new AddressList(data.initiatedByList);
+    }
+    clone() {
+        return super.clone();
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    castToCollectionApprovalPermission(address) {
+        return new CollectionApprovalPermissionWithDetails({
+            ...this,
+            fromList: getReservedAddressList(address),
+            fromListId: address
+        });
+    }
+}
+export class CollectionPermissionsWithDetails extends CollectionPermissions {
+    canUpdateCollectionApprovals;
+    constructor(data) {
+        super(data);
+        this.canUpdateCollectionApprovals = data.canUpdateCollectionApprovals.map((canUpdateCollectionApproval) => new CollectionApprovalPermissionWithDetails(canUpdateCollectionApproval));
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+    clone() {
+        return super.clone();
+    }
+    static validateUpdate(oldPermissions, newPermissions) {
+        return CollectionPermissions.validateUpdate(oldPermissions, newPermissions);
+    }
+}
+export class UserPermissionsWithDetails extends UserPermissions {
+    canUpdateIncomingApprovals;
+    canUpdateOutgoingApprovals;
+    canUpdateAutoApproveSelfInitiatedOutgoingTransfers;
+    canUpdateAutoApproveSelfInitiatedIncomingTransfers;
+    constructor(data) {
+        super(data);
+        this.canUpdateIncomingApprovals = data.canUpdateIncomingApprovals.map((canUpdateUserIncomingApproval) => new UserIncomingApprovalPermissionWithDetails(canUpdateUserIncomingApproval));
+        this.canUpdateOutgoingApprovals = data.canUpdateOutgoingApprovals.map((canUpdateUserOutgoingApproval) => new UserOutgoingApprovalPermissionWithDetails(canUpdateUserOutgoingApproval));
+        this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers = data.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((actionPermission) => new ActionPermission(actionPermission));
+        this.canUpdateAutoApproveSelfInitiatedIncomingTransfers = data.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((actionPermission) => new ActionPermission(actionPermission));
+    }
+    convert(convertFunction) {
+        return convertClassPropertiesAndMaintainNumberTypes(this, convertFunction);
+    }
+}
+function checkNotForbidden(permission, time) {
+    const blockTime = time ?? BigInt(Date.now());
+    const [, found] = permission.permanentlyForbiddenTimes.search(blockTime);
+    if (found) {
+        return new Error(`permission is forbidden from being executed at current time ${new Date(Number(blockTime)).toLocaleDateString() + ' ' + new Date(Number(blockTime)).toLocaleTimeString()}`);
+    }
+    return null;
+}
+function checkNotForbiddenForAllOverlaps(permissionDetails, detailsToCheck, time = undefined, usesLists) {
+    let usesBadgeIds = true;
+    let usesTimelineTimes = true;
+    let usesTransferTimes = true;
+    let usesOwnershipTimes = true;
+    let usesToLists = true;
+    let usesFromLists = true;
+    let usesInitiatedByLists = true;
+    let usesApprovalIdLists = true;
+    let usesAmountTrackerIdList = true;
+    let usesChallengeTrackerIdList = true;
+    for (const detailToCheck of detailsToCheck) {
+        if (detailToCheck.badgeId.start === -1n) {
+            usesBadgeIds = false;
+            detailToCheck.badgeId = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.timelineTime.start === -1n) {
+            usesTimelineTimes = false;
+            detailToCheck.timelineTime = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.transferTime.start === -1n) {
+            usesTransferTimes = false;
+            detailToCheck.transferTime = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (detailToCheck.ownershipTime.start === -1n) {
+            usesOwnershipTimes = false;
+            detailToCheck.ownershipTime = new UintRange({ start: BigInt(1n), end: BigInt(1n) });
+        }
+        if (!usesLists) {
+            usesToLists = false;
+            detailToCheck.toList = AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesFromLists = false;
+            detailToCheck.fromList = AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesInitiatedByLists = false;
+            detailToCheck.initiatedByList = AddressList.AllAddresses();
+        }
+        if (!usesLists) {
+            usesApprovalIdLists = false;
+            detailToCheck.approvalIdList = AddressList.AllAddresses();
+        }
+    }
+    for (const permissionDetail of permissionDetails) {
+        for (const detailToCheck of detailsToCheck) {
+            const [, overlap] = universalRemoveOverlaps(permissionDetail, detailToCheck);
+            if (overlap.length > 0) {
+                const err = checkNotForbidden(permissionDetail, time);
+                if (err) {
+                    let errStr = err.message;
+                    if (usesTimelineTimes) {
+                        errStr += ` for the timeline times ${new Date(Number(permissionDetail.timelineTime.start)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.timelineTime.start)).toLocaleTimeString()} to ${new Date(Number(permissionDetail.timelineTime.end)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.timelineTime.end)).toLocaleTimeString()}`;
+                    }
+                    if (usesTransferTimes) {
+                        errStr += ` for the transfer times ${new Date(Number(permissionDetail.transferTime.start)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.transferTime.start)).toLocaleTimeString()} to ${new Date(Number(permissionDetail.transferTime.end)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.transferTime.end)).toLocaleTimeString()}`;
+                    }
+                    if (usesBadgeIds) {
+                        errStr += ` for the badge ids ${permissionDetail.badgeId.start} to ${permissionDetail.badgeId.end}`;
+                    }
+                    if (usesOwnershipTimes) {
+                        errStr += ` for the ownership times ${new Date(Number(permissionDetail.ownershipTime.start)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.ownershipTime.start)).toLocaleTimeString()} to ${new Date(Number(permissionDetail.ownershipTime.end)).toLocaleDateString() + ' ' + new Date(Number(permissionDetail.ownershipTime.end)).toLocaleTimeString()}`;
+                    }
+                    if (usesToLists) {
+                        errStr += ` for the to lists ${permissionDetail.toList.listId}`;
+                    }
+                    if (usesFromLists) {
+                        errStr += ` for the from lists ${permissionDetail.fromList.listId}`;
+                    }
+                    if (usesInitiatedByLists) {
+                        errStr += ` for the initiated by lists ${permissionDetail.initiatedByList.listId}`;
+                    }
+                    if (usesApprovalIdLists) {
+                        errStr += ` for the approval id ${permissionDetail.approvalIdList.listId}`;
+                    }
+                    return new Error(errStr);
+                }
+            }
+        }
+    }
+    return null;
+}
+function validateUniversalPermissionUpdate(oldPermissions, newPermissions) {
+    const [allOverlaps, inOldButNotNew] = getOverlapsAndNonOverlaps(oldPermissions, newPermissions);
+    if (inOldButNotNew.length > 0) {
+        let errMsg = `Permission ${getPermissionString(inOldButNotNew[0])} found in old permissions but not in new permissions`;
+        if (inOldButNotNew.length > 1) {
+            errMsg += ` (along with ${inOldButNotNew.length - 1} more)`;
+        }
+        return new Error(errMsg);
+    }
+    for (const overlapObj of allOverlaps) {
+        const oldPermission = overlapObj.firstDetails;
+        const newPermission = overlapObj.secondDetails;
+        const [leftoverPermittedTimes] = oldPermission.permanentlyPermittedTimes.getOverlapDetails(newPermission.permanentlyPermittedTimes);
+        const [leftoverForbiddenTimes] = oldPermission.permanentlyForbiddenTimes.getOverlapDetails(newPermission.permanentlyForbiddenTimes);
+        if (leftoverPermittedTimes.length > 0 || leftoverForbiddenTimes.length > 0) {
+            let errMsg = `Permission ${getPermissionString(oldPermission)} found in both new and old permissions but `;
+            if (leftoverPermittedTimes.length > 0) {
+                errMsg += 'previously explicitly allowed the times ( ';
+                for (const oldPermittedTime of leftoverPermittedTimes) {
+                    errMsg += `${oldPermittedTime.start}-${oldPermittedTime.end} `;
+                }
+                errMsg += ') which are now set to disApproved';
+            }
+            if (leftoverForbiddenTimes.length > 0 && leftoverPermittedTimes.length > 0) {
+                errMsg += ' and';
+            }
+            if (leftoverForbiddenTimes.length > 0) {
+                errMsg += ' previously explicitly disApproved the times ( ';
+                for (const oldForbiddenTime of leftoverForbiddenTimes) {
+                    errMsg += `${oldForbiddenTime.start}-${oldForbiddenTime.end} `;
+                }
+                errMsg += ') which are now set to allowed.';
+            }
+            return new Error(errMsg);
+        }
+    }
+    return null;
+}
+function getPermissionString(permission) {
+    let str = '(';
+    const maxUint64 = 18446744073709551615n;
+    if (permission.badgeId.start === maxUint64 || permission.badgeId.end === maxUint64) {
+        str += `badgeId: ${permission.badgeId.start} `;
+    }
+    if (permission.timelineTime.start === maxUint64 || permission.timelineTime.end === maxUint64) {
+        str += `timelineTime: ${permission.timelineTime.start} `;
+    }
+    if (permission.transferTime.start === maxUint64 || permission.transferTime.end === maxUint64) {
+        str += `transferTime: ${permission.transferTime.start} `;
+    }
+    if (permission.ownershipTime.start === maxUint64 || permission.ownershipTime.end === maxUint64) {
+        str += `ownershipTime: ${permission.ownershipTime.start} `;
+    }
+    if (permission.toList) {
+        str += 'toList: ';
+        if (!permission.toList.whitelist) {
+            str += `${permission.toList.addresses.length} addresses `;
+        }
+        else {
+            str += `all except ${permission.toList.addresses.length} addresses `;
+        }
+        if (permission.toList.addresses.length > 0 && permission.toList.addresses.length <= 5) {
+            str += '(';
+            for (const address of permission.toList.addresses) {
+                str += address + ' ';
+            }
+            str += ')';
+        }
+    }
+    if (permission.fromList) {
+        str += 'fromList: ';
+        if (!permission.fromList.whitelist) {
+            str += `${permission.fromList.addresses.length} addresses `;
+        }
+        else {
+            str += `all except ${permission.fromList.addresses.length} addresses `;
+        }
+        if (permission.fromList.addresses.length > 0 && permission.fromList.addresses.length <= 5) {
+            str += '(';
+            for (const address of permission.fromList.addresses) {
+                str += address + ' ';
+            }
+            str += ')';
+        }
+    }
+    if (permission.initiatedByList) {
+        str += 'initiatedByList: ';
+        if (!permission.initiatedByList.whitelist) {
+            str += `${permission.initiatedByList.addresses.length} addresses `;
+        }
+        else {
+            str += `all except ${permission.initiatedByList.addresses.length} addresses `;
+        }
+        if (permission.initiatedByList.addresses.length > 0 && permission.initiatedByList.addresses.length <= 5) {
+            str += '(';
+            for (const address of permission.initiatedByList.addresses) {
+                str += address + ' ';
+            }
+            str += ')';
+        }
+    }
+    str += ') ';
+    return str;
+}
+//# sourceMappingURL=permissions.js.map