bitbadgesjs-sdk 0.0.6 → 0.1.0

package/dist/types/badges/typeutils/permissions.js

@@ -0,0 +1,675 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionApprovalPermission = exports.TimedUpdateWithBadgeIdsPermission = exports.BalancesActionPermission = exports.TimedUpdatePermission = exports.ActionPermission = exports.CollectionPermissions = exports.getPermissionVariablesFromName = exports.UserIncomingApprovalPermission = exports.UserOutgoingApprovalPermission = exports.UserPermissions = void 0;
+const __1 = require("../../..");
+const string_numbers_1 = require("../string-numbers");
+const typeUtils_1 = require("./typeUtils");
+const proto_1 = require("../../../proto");
+class UserPermissions extends typeUtils_1.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));
+    }
+    static required() {
+        return new UserPermissions({
+            canUpdateOutgoingApprovals: [],
+            canUpdateIncomingApprovals: [],
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: [],
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: []
+        });
+    }
+    convert(convertFunction) {
+        return new UserPermissions((0, typeUtils_1.deepCopy)({
+            canUpdateOutgoingApprovals: this.canUpdateOutgoingApprovals.map((x) => x.convert(convertFunction)),
+            canUpdateIncomingApprovals: this.canUpdateIncomingApprovals.map((x) => x.convert(convertFunction)),
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: this.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map((x) => x.convert(convertFunction)),
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: this.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto_1.badges.UserPermissions(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.UserPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.UserPermissions.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new UserPermissions({
+            canUpdateOutgoingApprovals: protoMsg.canUpdateOutgoingApprovals.map(x => UserOutgoingApprovalPermission.convertFromProto(x, convertFunction)),
+            canUpdateIncomingApprovals: protoMsg.canUpdateIncomingApprovals.map(x => UserIncomingApprovalPermission.convertFromProto(x, convertFunction)),
+            canUpdateAutoApproveSelfInitiatedOutgoingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedOutgoingTransfers.map(x => ActionPermission.convertFromProto(x, convertFunction)),
+            canUpdateAutoApproveSelfInitiatedIncomingTransfers: protoMsg.canUpdateAutoApproveSelfInitiatedIncomingTransfers.map(x => ActionPermission.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.UserPermissions = UserPermissions;
+class UserOutgoingApprovalPermission extends typeUtils_1.BaseNumberTypeClass {
+    toListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.toListId = msg.toListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.transferTimes = msg.transferTimes.map(x => new typeUtils_1.UintRange(x));
+        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
+        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new UserOutgoingApprovalPermission({
+            toListId: '',
+            initiatedByListId: '',
+            transferTimes: [],
+            badgeIds: [],
+            ownershipTimes: [],
+            approvalId: '',
+            amountTrackerId: '',
+            challengeTrackerId: '',
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new UserOutgoingApprovalPermission((0, typeUtils_1.deepCopy)({
+            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,
+            amountTrackerId: this.amountTrackerId,
+            challengeTrackerId: this.challengeTrackerId,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto_1.badges.UserOutgoingApprovalPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.UserOutgoingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.UserOutgoingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new UserOutgoingApprovalPermission({
+            toListId: protoMsg.toListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            amountTrackerId: protoMsg.amountTrackerId,
+            challengeTrackerId: protoMsg.challengeTrackerId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.UserOutgoingApprovalPermission = UserOutgoingApprovalPermission;
+class UserIncomingApprovalPermission extends typeUtils_1.BaseNumberTypeClass {
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.transferTimes = msg.transferTimes.map(x => new typeUtils_1.UintRange(x));
+        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
+        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new UserIncomingApprovalPermission({
+            fromListId: '',
+            initiatedByListId: '',
+            transferTimes: [],
+            badgeIds: [],
+            ownershipTimes: [],
+            approvalId: '',
+            amountTrackerId: '',
+            challengeTrackerId: '',
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new UserIncomingApprovalPermission((0, typeUtils_1.deepCopy)({
+            fromListId: this.fromListId,
+            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,
+            amountTrackerId: this.amountTrackerId,
+            challengeTrackerId: this.challengeTrackerId,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto_1.badges.UserIncomingApprovalPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.UserIncomingApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.UserIncomingApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new UserIncomingApprovalPermission({
+            fromListId: protoMsg.fromListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            amountTrackerId: protoMsg.amountTrackerId,
+            challengeTrackerId: protoMsg.challengeTrackerId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.UserIncomingApprovalPermission = UserIncomingApprovalPermission;
+const getPermissionVariablesFromName = (permissionName) => {
+    let castFunction = () => { return []; };
+    let flags = __1.ApprovalPermissionUsedFlags;
+    let validateFunction = undefined;
+    let validatePermissionUpdateFunction = undefined;
+    switch (permissionName) {
+        case 'canArchiveCollection':
+            validateFunction = __1.validateIsArchivedUpdate;
+            break;
+        case 'canUpdateOffChainBalancesMetadata':
+            validateFunction = __1.validateOffChainBalancesMetadataUpdate;
+            break;
+        case 'canUpdateManager':
+            validateFunction = __1.validateManagerUpdate;
+            break;
+        case 'canUpdateCollectionMetadata':
+            validateFunction = __1.validateCollectionMetadataUpdate;
+            break;
+        case 'canUpdateBadgeMetadata':
+            validateFunction = __1.validateBadgeMetadataUpdate;
+            break;
+        case 'canUpdateCollectionApprovals':
+            validateFunction = __1.validateCollectionApprovalsUpdate;
+            break;
+    }
+    switch (permissionName) {
+        case 'canDeleteCollection':
+        case 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers':
+        case 'canUpdateAutoApproveSelfInitiatedIncomingTransfers':
+            validatePermissionUpdateFunction = __1.validateActionPermissionUpdate;
+            break;
+        case 'canArchiveCollection':
+        case 'canUpdateOffChainBalancesMetadata':
+        case 'canUpdateStandards':
+        case 'canUpdateCustomData':
+        case 'canUpdateManager':
+        case 'canUpdateCollectionMetadata':
+            validatePermissionUpdateFunction = __1.validateTimedUpdatePermissionUpdate;
+            break;
+        case 'canCreateMoreBadges':
+            validatePermissionUpdateFunction = __1.validateBalancesActionPermissionUpdate;
+            break;
+        case 'canUpdateBadgeMetadata':
+            validatePermissionUpdateFunction = __1.validateTimedUpdateWithBadgeIdsPermissionUpdate;
+            break;
+        case 'canUpdateCollectionApprovals':
+            validatePermissionUpdateFunction = __1.validateCollectionApprovalPermissionsUpdate;
+            break;
+    }
+    let question = "";
+    switch (permissionName) {
+        case 'canDeleteCollection':
+            question = "Can delete the collection?";
+            break;
+        case 'canArchiveCollection':
+            question = "Can archive the collection?";
+            break;
+        case 'canUpdateOffChainBalancesMetadata':
+            question = "Can update the off-chain balances metadata?";
+            break;
+        case 'canUpdateStandards':
+            question = "Can update the standards?";
+            break;
+        case 'canUpdateCustomData':
+            question = "Can update the custom data?";
+            break;
+        case 'canUpdateManager':
+            question = "Can update the manager?";
+            break;
+        case 'canUpdateCollectionMetadata':
+            question = "Can update the collection metadata?";
+            break;
+        case 'canCreateMoreBadges':
+            question = "Can create more badges?";
+            break;
+        case 'canUpdateBadgeMetadata':
+            question = "Can update the badge metadata?";
+            break;
+        case 'canUpdateCollectionApprovals':
+            question = "Can update collection approvals?";
+            break;
+        case 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers':
+            question = "Can update auto approve self initiated outgoing transfers?";
+            break;
+        case 'canUpdateAutoApproveSelfInitiatedIncomingTransfers':
+            question = "Can update auto approve self initiated incoming transfers?";
+            break;
+    }
+    switch (permissionName) {
+        case 'canDeleteCollection':
+        case 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers':
+        case 'canUpdateAutoApproveSelfInitiatedIncomingTransfers':
+            castFunction = __1.castActionPermissionToUniversalPermission;
+            flags = __1.ActionPermissionUsedFlags;
+            break;
+        case 'canArchiveCollection':
+        case 'canUpdateOffChainBalancesMetadata':
+        case 'canUpdateStandards':
+        case 'canUpdateCustomData':
+        case 'canUpdateManager':
+        case 'canUpdateCollectionMetadata':
+            castFunction = __1.castTimedUpdatePermissionToUniversalPermission;
+            flags = __1.TimedUpdatePermissionUsedFlags;
+            break;
+        case 'canCreateMoreBadges':
+            castFunction = __1.castBalancesActionPermissionToUniversalPermission;
+            flags = __1.BalancesActionPermissionUsedFlags;
+            break;
+        case 'canUpdateBadgeMetadata':
+            castFunction = __1.castTimedUpdateWithBadgeIdsPermissionToUniversalPermission;
+            flags = __1.TimedUpdateWithBadgeIdsPermissionUsedFlags;
+            break;
+        case 'canUpdateCollectionApprovals':
+            castFunction = __1.castCollectionApprovalPermissionToUniversalPermission;
+            flags = __1.ApprovalPermissionUsedFlags;
+            break;
+    }
+    if (!castFunction)
+        throw new Error('');
+    return {
+        castFunction,
+        flags,
+        question,
+        validateFunction,
+        validatePermissionUpdateFunction
+    };
+};
+exports.getPermissionVariablesFromName = getPermissionVariablesFromName;
+class CollectionPermissions extends typeUtils_1.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));
+    }
+    static required() {
+        return new CollectionPermissions({
+            canDeleteCollection: [],
+            canArchiveCollection: [],
+            canUpdateOffChainBalancesMetadata: [],
+            canUpdateStandards: [],
+            canUpdateCustomData: [],
+            canUpdateManager: [],
+            canUpdateCollectionMetadata: [],
+            canCreateMoreBadges: [],
+            canUpdateBadgeMetadata: [],
+            canUpdateCollectionApprovals: []
+        });
+    }
+    convert(convertFunction) {
+        return new CollectionPermissions((0, typeUtils_1.deepCopy)({
+            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 proto_1.badges.CollectionPermissions(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.CollectionPermissions.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.CollectionPermissions.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new CollectionPermissions({
+            canDeleteCollection: protoMsg.canDeleteCollection.map(x => ActionPermission.convertFromProto(x, convertFunction)),
+            canArchiveCollection: protoMsg.canArchiveCollection.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
+            canUpdateOffChainBalancesMetadata: protoMsg.canUpdateOffChainBalancesMetadata.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
+            canUpdateStandards: protoMsg.canUpdateStandards.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
+            canUpdateCustomData: protoMsg.canUpdateCustomData.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
+            canUpdateManager: protoMsg.canUpdateManager.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
+            canUpdateCollectionMetadata: protoMsg.canUpdateCollectionMetadata.map(x => TimedUpdatePermission.convertFromProto(x, convertFunction)),
+            canCreateMoreBadges: protoMsg.canCreateMoreBadges.map(x => BalancesActionPermission.convertFromProto(x, convertFunction)),
+            canUpdateBadgeMetadata: protoMsg.canUpdateBadgeMetadata.map(x => TimedUpdateWithBadgeIdsPermission.convertFromProto(x, convertFunction)),
+            canUpdateCollectionApprovals: protoMsg.canUpdateCollectionApprovals.map(x => CollectionApprovalPermission.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.CollectionPermissions = CollectionPermissions;
+class ActionPermission extends typeUtils_1.BaseNumberTypeClass {
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new ActionPermission({
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new ActionPermission((0, typeUtils_1.deepCopy)({
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto_1.badges.ActionPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.ActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.ActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new ActionPermission({
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.ActionPermission = ActionPermission;
+class TimedUpdatePermission extends typeUtils_1.BaseNumberTypeClass {
+    timelineTimes;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.timelineTimes = msg.timelineTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new TimedUpdatePermission({
+            timelineTimes: [],
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new TimedUpdatePermission((0, typeUtils_1.deepCopy)({
+            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 proto_1.badges.TimedUpdatePermission(this.convert(string_numbers_1.Stringify));
+    }
+    equals(other, normalizeNumberTypes) {
+        return (0, typeUtils_1.compareNumberTypeConvertibles)(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.TimedUpdatePermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.TimedUpdatePermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new TimedUpdatePermission({
+            timelineTimes: protoMsg.timelineTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.TimedUpdatePermission = TimedUpdatePermission;
+class BalancesActionPermission extends typeUtils_1.BaseNumberTypeClass {
+    badgeIds;
+    ownershipTimes;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
+        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new BalancesActionPermission({
+            badgeIds: [],
+            ownershipTimes: [],
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new BalancesActionPermission((0, typeUtils_1.deepCopy)({
+            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 proto_1.badges.BalancesActionPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.BalancesActionPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.BalancesActionPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new BalancesActionPermission({
+            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.BalancesActionPermission = BalancesActionPermission;
+class TimedUpdateWithBadgeIdsPermission extends typeUtils_1.BaseNumberTypeClass {
+    timelineTimes;
+    badgeIds;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.timelineTimes = msg.timelineTimes.map(x => new typeUtils_1.UintRange(x));
+        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new TimedUpdateWithBadgeIdsPermission({
+            timelineTimes: [],
+            badgeIds: [],
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission((0, typeUtils_1.deepCopy)({
+            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 proto_1.badges.TimedUpdateWithBadgeIdsPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.TimedUpdateWithBadgeIdsPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.TimedUpdateWithBadgeIdsPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new TimedUpdateWithBadgeIdsPermission({
+            timelineTimes: protoMsg.timelineTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.TimedUpdateWithBadgeIdsPermission = TimedUpdateWithBadgeIdsPermission;
+class CollectionApprovalPermission extends typeUtils_1.BaseNumberTypeClass {
+    fromListId;
+    toListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    permanentlyPermittedTimes;
+    permanentlyForbiddenTimes;
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        this.toListId = msg.toListId;
+        this.initiatedByListId = msg.initiatedByListId;
+        this.transferTimes = msg.transferTimes.map(x => new typeUtils_1.UintRange(x));
+        this.badgeIds = msg.badgeIds.map(x => new typeUtils_1.UintRange(x));
+        this.ownershipTimes = msg.ownershipTimes.map(x => new typeUtils_1.UintRange(x));
+        this.approvalId = msg.approvalId;
+        this.amountTrackerId = msg.amountTrackerId;
+        this.challengeTrackerId = msg.challengeTrackerId;
+        this.permanentlyPermittedTimes = msg.permanentlyPermittedTimes.map(x => new typeUtils_1.UintRange(x));
+        this.permanentlyForbiddenTimes = msg.permanentlyForbiddenTimes.map(x => new typeUtils_1.UintRange(x));
+    }
+    static required() {
+        return new CollectionApprovalPermission({
+            fromListId: '',
+            toListId: '',
+            initiatedByListId: '',
+            transferTimes: [],
+            badgeIds: [],
+            ownershipTimes: [],
+            approvalId: '',
+            amountTrackerId: '',
+            challengeTrackerId: '',
+            permanentlyPermittedTimes: [],
+            permanentlyForbiddenTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new CollectionApprovalPermission((0, typeUtils_1.deepCopy)({
+            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,
+            amountTrackerId: this.amountTrackerId,
+            challengeTrackerId: this.challengeTrackerId,
+            permanentlyPermittedTimes: this.permanentlyPermittedTimes.map((x) => x.convert(convertFunction)),
+            permanentlyForbiddenTimes: this.permanentlyForbiddenTimes.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new proto_1.badges.CollectionApprovalPermission(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.CollectionApprovalPermission.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(proto_1.badges.CollectionApprovalPermission.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(protoMsg, convertFunction) {
+        return new CollectionApprovalPermission({
+            fromListId: protoMsg.fromListId,
+            toListId: protoMsg.toListId,
+            initiatedByListId: protoMsg.initiatedByListId,
+            transferTimes: protoMsg.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: protoMsg.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: protoMsg.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            approvalId: protoMsg.approvalId,
+            amountTrackerId: protoMsg.amountTrackerId,
+            challengeTrackerId: protoMsg.challengeTrackerId,
+            permanentlyPermittedTimes: protoMsg.permanentlyPermittedTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            permanentlyForbiddenTimes: protoMsg.permanentlyForbiddenTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.CollectionApprovalPermission = CollectionApprovalPermission;
+//# sourceMappingURL=permissions.js.map