bitbadgesjs-sdk 0.0.6 → 0.1.0

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

@@ -0,0 +1,690 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalCriteria = exports.CollectionApproval = exports.IncomingApprovalCriteria = exports.UserIncomingApproval = exports.MaxNumTransfers = exports.ApprovalAmounts = exports.PredeterminedOrderCalculationMethod = exports.IncrementedBalances = exports.ManualBalances = exports.PredeterminedBalances = exports.OutgoingApprovalCriteria = exports.UserOutgoingApproval = exports.UserBalanceStore = void 0;
+const __1 = require("../../..");
+const __2 = require("../../..");
+const string_numbers_1 = require("../string-numbers");
+const permissions_1 = require("./permissions");
+const typeUtils_1 = require("./typeUtils");
+class UserBalanceStore extends typeUtils_1.BaseNumberTypeClass {
+    balances;
+    incomingApprovals;
+    outgoingApprovals;
+    userPermissions;
+    autoApproveSelfInitiatedOutgoingTransfers;
+    autoApproveSelfInitiatedIncomingTransfers;
+    constructor(msg) {
+        super();
+        this.balances = msg.balances.map(x => new typeUtils_1.Balance(x));
+        this.incomingApprovals = msg.incomingApprovals.map(x => new UserIncomingApproval(x));
+        this.outgoingApprovals = msg.outgoingApprovals.map(x => new UserOutgoingApproval(x));
+        this.userPermissions = new permissions_1.UserPermissions(msg.userPermissions);
+        this.autoApproveSelfInitiatedOutgoingTransfers = msg.autoApproveSelfInitiatedOutgoingTransfers;
+        this.autoApproveSelfInitiatedIncomingTransfers = msg.autoApproveSelfInitiatedIncomingTransfers;
+    }
+    convert(convertFunction) {
+        return new UserBalanceStore((0, typeUtils_1.deepCopy)({
+            balances: this.balances.map((x) => x.convert(convertFunction)),
+            incomingApprovals: this.incomingApprovals.map((x) => x.convert(convertFunction)),
+            outgoingApprovals: this.outgoingApprovals.map((x) => x.convert(convertFunction)),
+            userPermissions: this.userPermissions.convert(convertFunction),
+            autoApproveSelfInitiatedOutgoingTransfers: this.autoApproveSelfInitiatedOutgoingTransfers,
+            autoApproveSelfInitiatedIncomingTransfers: this.autoApproveSelfInitiatedIncomingTransfers
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.UserBalanceStore(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UserBalanceStore.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UserBalanceStore.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new UserBalanceStore({
+            balances: item.balances.map(x => typeUtils_1.Balance.convertFromProto(x, convertFunction)),
+            incomingApprovals: item.incomingApprovals.map(x => UserIncomingApproval.convertFromProto(x, convertFunction)),
+            outgoingApprovals: item.outgoingApprovals.map(x => UserOutgoingApproval.convertFromProto(x, convertFunction)),
+            userPermissions: item.userPermissions ? permissions_1.UserPermissions.convertFromProto(item.userPermissions, convertFunction) : permissions_1.UserPermissions.required().convert(convertFunction),
+            autoApproveSelfInitiatedOutgoingTransfers: item.autoApproveSelfInitiatedOutgoingTransfers,
+            autoApproveSelfInitiatedIncomingTransfers: item.autoApproveSelfInitiatedIncomingTransfers
+        });
+    }
+    getBalanceForIdAndTime(badgeId, ownedTime) {
+        return (0, __2.getBalanceForIdAndTime)(badgeId, ownedTime, this.balances.map(x => x.convert(string_numbers_1.BigIntify)));
+    }
+    getBalancesForId(badgeId) {
+        return (0, __1.getBalancesForId)(badgeId, this.balances.map(x => x.convert(string_numbers_1.BigIntify)));
+    }
+    getBalancesForTime(ownedTime) {
+        return (0, __1.getBalancesForTime)(ownedTime, this.balances.map(x => x.convert(string_numbers_1.BigIntify)));
+    }
+    filterZeroBalances() {
+        this.balances = this.balances.filter(x => x.amount !== BigInt(0));
+    }
+    subsetOf(threshold) {
+        return (0, __1.doBalancesExceedThreshold)(this.balances.map(x => x.convert(string_numbers_1.BigIntify)), threshold.balances.map(x => x.convert(string_numbers_1.BigIntify)));
+    }
+    equalBalances(other, checkZeroBalances = false) {
+        return (0, __1.areBalancesEqual)(this.balances.map(x => x.convert(string_numbers_1.BigIntify)), other.balances.map(x => x.convert(string_numbers_1.BigIntify)), checkZeroBalances);
+    }
+    updateBalances(newBalance) {
+        this.balances = (0, __1.updateBalances)(newBalance, this.balances);
+    }
+    addBalances(balancesToAdd) {
+        this.balances = (0, __1.addBalances)(balancesToAdd, this.balances);
+    }
+    addBalance(balanceToAdd) {
+        this.addBalances([balanceToAdd]);
+    }
+    subtractBalances(balancesToSubtract, allowUnderflow) {
+        this.balances = (0, __2.subtractBalances)(balancesToSubtract, this.balances, allowUnderflow);
+    }
+    subtractBalance(balanceToSubtract, allowUnderflow) {
+        this.subtractBalances([balanceToSubtract], allowUnderflow);
+    }
+    sortBalancesByAmount() {
+        this.balances = (0, __1.sortBalancesByAmount)(this.balances);
+    }
+    applyIncrements(incrementBadgeIdsBy, incrementOwnershipTimesBy, numIncrements) {
+        this.balances = (0, __1.applyIncrementsToBalances)(this.balances, incrementBadgeIdsBy, incrementOwnershipTimesBy, numIncrements);
+    }
+    getBalancesAfterTransfers(transfers, allowUnderflow) {
+        return (0, __1.getBalancesAfterTransfers)(this.balances, transfers, allowUnderflow);
+    }
+}
+exports.UserBalanceStore = UserBalanceStore;
+class UserOutgoingApproval extends typeUtils_1.BaseNumberTypeClass {
+    toListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    approvalCriteria;
+    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.uri = msg.uri;
+        this.customData = msg.customData;
+        this.approvalCriteria = msg.approvalCriteria ? new OutgoingApprovalCriteria(msg.approvalCriteria) : undefined;
+    }
+    convert(convertFunction) {
+        return new UserOutgoingApproval((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,
+            uri: this.uri,
+            customData: this.customData,
+            approvalCriteria: this.approvalCriteria?.convert(convertFunction)
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.UserOutgoingApproval(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UserOutgoingApproval.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UserOutgoingApproval.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new UserOutgoingApproval({
+            toListId: item.toListId,
+            initiatedByListId: item.initiatedByListId,
+            transferTimes: item.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: item.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            approvalId: item.approvalId,
+            amountTrackerId: item.amountTrackerId,
+            challengeTrackerId: item.challengeTrackerId,
+            uri: item.uri,
+            customData: item.customData,
+            approvalCriteria: item.approvalCriteria ? OutgoingApprovalCriteria.convertFromProto(item.approvalCriteria, convertFunction) : undefined
+        });
+    }
+}
+exports.UserOutgoingApproval = UserOutgoingApproval;
+class OutgoingApprovalCriteria extends typeUtils_1.BaseNumberTypeClass {
+    mustOwnBadges;
+    merkleChallenge;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireToEqualsInitiatedBy;
+    requireToDoesNotEqualInitiatedBy;
+    constructor(msg) {
+        super();
+        this.mustOwnBadges = msg.mustOwnBadges?.map(x => new typeUtils_1.MustOwnBadges(x));
+        this.merkleChallenge = msg.merkleChallenge ? new typeUtils_1.MerkleChallenge(msg.merkleChallenge) : undefined;
+        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
+        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
+        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
+        this.requireToEqualsInitiatedBy = msg.requireToEqualsInitiatedBy;
+        this.requireToDoesNotEqualInitiatedBy = msg.requireToDoesNotEqualInitiatedBy;
+    }
+    convert(convertFunction) {
+        return new OutgoingApprovalCriteria((0, typeUtils_1.deepCopy)({
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            merkleChallenge: this.merkleChallenge?.convert(convertFunction),
+            predeterminedBalances: this.predeterminedBalances?.convert(convertFunction),
+            approvalAmounts: this.approvalAmounts?.convert(convertFunction),
+            maxNumTransfers: this.maxNumTransfers?.convert(convertFunction),
+            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.OutgoingApprovalCriteria(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.OutgoingApprovalCriteria.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.OutgoingApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new OutgoingApprovalCriteria({
+            mustOwnBadges: item.mustOwnBadges.map(x => typeUtils_1.MustOwnBadges.convertFromProto(x, convertFunction)),
+            merkleChallenge: item.merkleChallenge ? typeUtils_1.MerkleChallenge.convertFromProto(item.merkleChallenge, convertFunction) : undefined,
+            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.convertFromProto(item.predeterminedBalances, convertFunction) : undefined,
+            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.convertFromProto(item.approvalAmounts, convertFunction) : undefined,
+            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.convertFromProto(item.maxNumTransfers, convertFunction) : undefined,
+            requireToEqualsInitiatedBy: item.requireToEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: item.requireToDoesNotEqualInitiatedBy
+        });
+    }
+}
+exports.OutgoingApprovalCriteria = OutgoingApprovalCriteria;
+class PredeterminedBalances extends typeUtils_1.BaseNumberTypeClass {
+    manualBalances;
+    incrementedBalances;
+    orderCalculationMethod;
+    constructor(msg) {
+        super();
+        this.manualBalances = msg.manualBalances.map(x => new ManualBalances(x));
+        this.incrementedBalances = new IncrementedBalances(msg.incrementedBalances);
+        this.orderCalculationMethod = new PredeterminedOrderCalculationMethod(msg.orderCalculationMethod);
+    }
+    convert(convertFunction) {
+        return new PredeterminedBalances((0, typeUtils_1.deepCopy)({
+            manualBalances: this.manualBalances.map((x) => x.convert(convertFunction)),
+            incrementedBalances: this.incrementedBalances.convert(convertFunction),
+            orderCalculationMethod: this.orderCalculationMethod
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.PredeterminedBalances(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.PredeterminedBalances.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.PredeterminedBalances.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new PredeterminedBalances({
+            manualBalances: item.manualBalances.map(x => ManualBalances.convertFromProto(x, convertFunction)),
+            incrementedBalances: item.incrementedBalances ? IncrementedBalances.convertFromProto(item.incrementedBalances, convertFunction) : new IncrementedBalances({ startBalances: [], incrementBadgeIdsBy: convertFunction(0), incrementOwnershipTimesBy: convertFunction(0) }),
+            orderCalculationMethod: item.orderCalculationMethod ? PredeterminedOrderCalculationMethod.convertFromProto(item.orderCalculationMethod) : new PredeterminedOrderCalculationMethod({
+                useOverallNumTransfers: false,
+                usePerFromAddressNumTransfers: false,
+                usePerToAddressNumTransfers: false,
+                usePerInitiatedByAddressNumTransfers: false,
+                useMerkleChallengeLeafIndex: false,
+            })
+        });
+    }
+}
+exports.PredeterminedBalances = PredeterminedBalances;
+class ManualBalances extends typeUtils_1.BaseNumberTypeClass {
+    balances;
+    constructor(msg) {
+        super();
+        this.balances = msg.balances.map(x => new typeUtils_1.Balance(x));
+    }
+    convert(convertFunction) {
+        return new ManualBalances((0, typeUtils_1.deepCopy)({
+            balances: this.balances.map((x) => x.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.ManualBalances(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ManualBalances.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ManualBalances.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new ManualBalances({
+            balances: item.balances.map(x => typeUtils_1.Balance.convertFromProto(x, convertFunction))
+        });
+    }
+}
+exports.ManualBalances = ManualBalances;
+class IncrementedBalances extends typeUtils_1.BaseNumberTypeClass {
+    startBalances;
+    incrementBadgeIdsBy;
+    incrementOwnershipTimesBy;
+    constructor(msg) {
+        super();
+        this.startBalances = msg.startBalances.map(x => new typeUtils_1.Balance(x));
+        this.incrementBadgeIdsBy = msg.incrementBadgeIdsBy;
+        this.incrementOwnershipTimesBy = msg.incrementOwnershipTimesBy;
+    }
+    convert(convertFunction) {
+        return new IncrementedBalances((0, typeUtils_1.deepCopy)({
+            startBalances: this.startBalances.map((x) => x.convert(convertFunction)),
+            incrementBadgeIdsBy: convertFunction(this.incrementBadgeIdsBy),
+            incrementOwnershipTimesBy: convertFunction(this.incrementOwnershipTimesBy)
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.IncrementedBalances(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.IncrementedBalances.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.IncrementedBalances.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new IncrementedBalances({
+            startBalances: item.startBalances.map(x => typeUtils_1.Balance.convertFromProto(x, convertFunction)),
+            incrementBadgeIdsBy: convertFunction(item.incrementBadgeIdsBy),
+            incrementOwnershipTimesBy: convertFunction(item.incrementOwnershipTimesBy)
+        });
+    }
+}
+exports.IncrementedBalances = IncrementedBalances;
+class PredeterminedOrderCalculationMethod extends typeUtils_1.CustomTypeClass {
+    useOverallNumTransfers;
+    usePerToAddressNumTransfers;
+    usePerFromAddressNumTransfers;
+    usePerInitiatedByAddressNumTransfers;
+    useMerkleChallengeLeafIndex;
+    constructor(msg) {
+        super();
+        this.useOverallNumTransfers = msg.useOverallNumTransfers;
+        this.usePerToAddressNumTransfers = msg.usePerToAddressNumTransfers;
+        this.usePerFromAddressNumTransfers = msg.usePerFromAddressNumTransfers;
+        this.usePerInitiatedByAddressNumTransfers = msg.usePerInitiatedByAddressNumTransfers;
+        this.useMerkleChallengeLeafIndex = msg.useMerkleChallengeLeafIndex;
+    }
+    clone() {
+        return (0, typeUtils_1.deepCopy)(this);
+    }
+    toProto() {
+        return new __1.proto.badges.PredeterminedOrderCalculationMethod(this.toJson());
+    }
+    static fromJson(jsonValue, options) {
+        return PredeterminedOrderCalculationMethod.fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return PredeterminedOrderCalculationMethod.fromJsonString(jsonString, options);
+    }
+    static convertFromProto(item) {
+        return new PredeterminedOrderCalculationMethod({
+            useOverallNumTransfers: item.useOverallNumTransfers,
+            usePerToAddressNumTransfers: item.usePerToAddressNumTransfers,
+            usePerFromAddressNumTransfers: item.usePerFromAddressNumTransfers,
+            usePerInitiatedByAddressNumTransfers: item.usePerInitiatedByAddressNumTransfers,
+            useMerkleChallengeLeafIndex: item.useMerkleChallengeLeafIndex
+        });
+    }
+}
+exports.PredeterminedOrderCalculationMethod = PredeterminedOrderCalculationMethod;
+class ApprovalAmounts extends typeUtils_1.BaseNumberTypeClass {
+    overallApprovalAmount;
+    perToAddressApprovalAmount;
+    perFromAddressApprovalAmount;
+    perInitiatedByAddressApprovalAmount;
+    constructor(msg) {
+        super();
+        this.overallApprovalAmount = msg.overallApprovalAmount;
+        this.perToAddressApprovalAmount = msg.perToAddressApprovalAmount;
+        this.perFromAddressApprovalAmount = msg.perFromAddressApprovalAmount;
+        this.perInitiatedByAddressApprovalAmount = msg.perInitiatedByAddressApprovalAmount;
+    }
+    convert(convertFunction) {
+        return new ApprovalAmounts((0, typeUtils_1.deepCopy)({
+            overallApprovalAmount: convertFunction(this.overallApprovalAmount),
+            perToAddressApprovalAmount: convertFunction(this.perToAddressApprovalAmount),
+            perFromAddressApprovalAmount: convertFunction(this.perFromAddressApprovalAmount),
+            perInitiatedByAddressApprovalAmount: convertFunction(this.perInitiatedByAddressApprovalAmount)
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.ApprovalAmounts(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ApprovalAmounts.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ApprovalAmounts.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new ApprovalAmounts({
+            overallApprovalAmount: convertFunction(item.overallApprovalAmount),
+            perToAddressApprovalAmount: convertFunction(item.perToAddressApprovalAmount),
+            perFromAddressApprovalAmount: convertFunction(item.perFromAddressApprovalAmount),
+            perInitiatedByAddressApprovalAmount: convertFunction(item.perInitiatedByAddressApprovalAmount)
+        });
+    }
+}
+exports.ApprovalAmounts = ApprovalAmounts;
+class MaxNumTransfers extends typeUtils_1.BaseNumberTypeClass {
+    overallMaxNumTransfers;
+    perToAddressMaxNumTransfers;
+    perFromAddressMaxNumTransfers;
+    perInitiatedByAddressMaxNumTransfers;
+    constructor(msg) {
+        super();
+        this.overallMaxNumTransfers = msg.overallMaxNumTransfers;
+        this.perToAddressMaxNumTransfers = msg.perToAddressMaxNumTransfers;
+        this.perFromAddressMaxNumTransfers = msg.perFromAddressMaxNumTransfers;
+        this.perInitiatedByAddressMaxNumTransfers = msg.perInitiatedByAddressMaxNumTransfers;
+    }
+    convert(convertFunction) {
+        return new MaxNumTransfers((0, typeUtils_1.deepCopy)({
+            overallMaxNumTransfers: convertFunction(this.overallMaxNumTransfers),
+            perToAddressMaxNumTransfers: convertFunction(this.perToAddressMaxNumTransfers),
+            perFromAddressMaxNumTransfers: convertFunction(this.perFromAddressMaxNumTransfers),
+            perInitiatedByAddressMaxNumTransfers: convertFunction(this.perInitiatedByAddressMaxNumTransfers)
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.MaxNumTransfers(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.MaxNumTransfers.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.MaxNumTransfers.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new MaxNumTransfers({
+            overallMaxNumTransfers: convertFunction(item.overallMaxNumTransfers),
+            perToAddressMaxNumTransfers: convertFunction(item.perToAddressMaxNumTransfers),
+            perFromAddressMaxNumTransfers: convertFunction(item.perFromAddressMaxNumTransfers),
+            perInitiatedByAddressMaxNumTransfers: convertFunction(item.perInitiatedByAddressMaxNumTransfers)
+        });
+    }
+}
+exports.MaxNumTransfers = MaxNumTransfers;
+class UserIncomingApproval extends typeUtils_1.BaseNumberTypeClass {
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    approvalCriteria;
+    constructor(msg) {
+        super();
+        this.fromListId = msg.fromListId;
+        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.uri = msg.uri;
+        this.customData = msg.customData;
+        this.approvalCriteria = msg.approvalCriteria ? new IncomingApprovalCriteria(msg.approvalCriteria) : undefined;
+    }
+    convert(convertFunction) {
+        return new UserIncomingApproval((0, typeUtils_1.deepCopy)({
+            fromListId: this.fromListId,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes.map((b) => b.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction)),
+            approvalId: this.approvalId,
+            amountTrackerId: this.amountTrackerId,
+            challengeTrackerId: this.challengeTrackerId,
+            uri: this.uri,
+            customData: this.customData,
+            approvalCriteria: this.approvalCriteria ? this.approvalCriteria.convert(convertFunction) : undefined
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.UserIncomingApproval(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UserIncomingApproval.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UserIncomingApproval.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new UserIncomingApproval({
+            fromListId: item.fromListId,
+            initiatedByListId: item.initiatedByListId,
+            transferTimes: item.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: item.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            approvalId: item.approvalId,
+            amountTrackerId: item.amountTrackerId,
+            challengeTrackerId: item.challengeTrackerId,
+            uri: item.uri,
+            customData: item.customData,
+            approvalCriteria: item.approvalCriteria ? IncomingApprovalCriteria.convertFromProto(item.approvalCriteria, convertFunction) : undefined
+        });
+    }
+}
+exports.UserIncomingApproval = UserIncomingApproval;
+class IncomingApprovalCriteria extends typeUtils_1.BaseNumberTypeClass {
+    mustOwnBadges;
+    merkleChallenge;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireFromEqualsInitiatedBy;
+    requireFromDoesNotEqualInitiatedBy;
+    constructor(msg) {
+        super();
+        this.mustOwnBadges = msg.mustOwnBadges?.map(x => new typeUtils_1.MustOwnBadges(x));
+        this.merkleChallenge = msg.merkleChallenge ? new typeUtils_1.MerkleChallenge(msg.merkleChallenge) : undefined;
+        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
+        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
+        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
+        this.requireFromEqualsInitiatedBy = msg.requireFromEqualsInitiatedBy;
+        this.requireFromDoesNotEqualInitiatedBy = msg.requireFromDoesNotEqualInitiatedBy;
+    }
+    convert(convertFunction) {
+        return new IncomingApprovalCriteria((0, typeUtils_1.deepCopy)({
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            merkleChallenge: this.merkleChallenge ? this.merkleChallenge.convert(convertFunction) : undefined,
+            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
+            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
+            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
+            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.IncomingApprovalCriteria(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.IncomingApprovalCriteria.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.IncomingApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new IncomingApprovalCriteria({
+            mustOwnBadges: item.mustOwnBadges.map(x => typeUtils_1.MustOwnBadges.convertFromProto(x, convertFunction)),
+            merkleChallenge: item.merkleChallenge ? typeUtils_1.MerkleChallenge.convertFromProto(item.merkleChallenge, convertFunction) : undefined,
+            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.convertFromProto(item.predeterminedBalances, convertFunction) : undefined,
+            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.convertFromProto(item.approvalAmounts, convertFunction) : undefined,
+            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.convertFromProto(item.maxNumTransfers, convertFunction) : undefined,
+            requireFromEqualsInitiatedBy: item.requireFromEqualsInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: item.requireFromDoesNotEqualInitiatedBy
+        });
+    }
+}
+exports.IncomingApprovalCriteria = IncomingApprovalCriteria;
+class CollectionApproval extends typeUtils_1.BaseNumberTypeClass {
+    toListId;
+    fromListId;
+    initiatedByListId;
+    transferTimes;
+    badgeIds;
+    ownershipTimes;
+    approvalId;
+    amountTrackerId;
+    challengeTrackerId;
+    uri;
+    customData;
+    approvalCriteria;
+    constructor(msg) {
+        super();
+        this.toListId = msg.toListId;
+        this.fromListId = msg.fromListId;
+        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.uri = msg.uri;
+        this.customData = msg.customData;
+        this.approvalCriteria = msg.approvalCriteria ? new ApprovalCriteria(msg.approvalCriteria) : undefined;
+    }
+    convert(convertFunction) {
+        return new CollectionApproval((0, typeUtils_1.deepCopy)({
+            toListId: this.toListId,
+            fromListId: this.fromListId,
+            initiatedByListId: this.initiatedByListId,
+            transferTimes: this.transferTimes.map((b) => b.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction)),
+            approvalId: this.approvalId,
+            amountTrackerId: this.amountTrackerId,
+            challengeTrackerId: this.challengeTrackerId,
+            uri: this.uri,
+            customData: this.customData,
+            approvalCriteria: this.approvalCriteria ? this.approvalCriteria.convert(convertFunction) : undefined
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.CollectionApproval(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CollectionApproval.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CollectionApproval.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new CollectionApproval({
+            toListId: item.toListId,
+            fromListId: item.fromListId,
+            initiatedByListId: item.initiatedByListId,
+            transferTimes: item.transferTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            badgeIds: item.badgeIds.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map(x => typeUtils_1.UintRange.convertFromProto(x, convertFunction)),
+            approvalId: item.approvalId,
+            amountTrackerId: item.amountTrackerId,
+            challengeTrackerId: item.challengeTrackerId,
+            uri: item.uri,
+            customData: item.customData,
+            approvalCriteria: item.approvalCriteria ? ApprovalCriteria.convertFromProto(item.approvalCriteria, convertFunction) : undefined
+        });
+    }
+}
+exports.CollectionApproval = CollectionApproval;
+class ApprovalCriteria extends typeUtils_1.BaseNumberTypeClass {
+    mustOwnBadges;
+    merkleChallenge;
+    predeterminedBalances;
+    approvalAmounts;
+    maxNumTransfers;
+    requireToEqualsInitiatedBy;
+    requireFromEqualsInitiatedBy;
+    requireToDoesNotEqualInitiatedBy;
+    requireFromDoesNotEqualInitiatedBy;
+    overridesFromOutgoingApprovals;
+    overridesToIncomingApprovals;
+    constructor(msg) {
+        super();
+        this.mustOwnBadges = msg.mustOwnBadges?.map(x => new typeUtils_1.MustOwnBadges(x));
+        this.merkleChallenge = msg.merkleChallenge ? new typeUtils_1.MerkleChallenge(msg.merkleChallenge) : undefined;
+        this.predeterminedBalances = msg.predeterminedBalances ? new PredeterminedBalances(msg.predeterminedBalances) : undefined;
+        this.approvalAmounts = msg.approvalAmounts ? new ApprovalAmounts(msg.approvalAmounts) : undefined;
+        this.maxNumTransfers = msg.maxNumTransfers ? new MaxNumTransfers(msg.maxNumTransfers) : undefined;
+        this.requireToEqualsInitiatedBy = msg.requireToEqualsInitiatedBy;
+        this.requireFromEqualsInitiatedBy = msg.requireFromEqualsInitiatedBy;
+        this.requireToDoesNotEqualInitiatedBy = msg.requireToDoesNotEqualInitiatedBy;
+        this.requireFromDoesNotEqualInitiatedBy = msg.requireFromDoesNotEqualInitiatedBy;
+        this.overridesFromOutgoingApprovals = msg.overridesFromOutgoingApprovals;
+        this.overridesToIncomingApprovals = msg.overridesToIncomingApprovals;
+    }
+    convert(convertFunction) {
+        return new ApprovalCriteria((0, typeUtils_1.deepCopy)({
+            mustOwnBadges: this.mustOwnBadges?.map((x) => x.convert(convertFunction)),
+            merkleChallenge: this.merkleChallenge ? this.merkleChallenge.convert(convertFunction) : undefined,
+            predeterminedBalances: this.predeterminedBalances ? this.predeterminedBalances.convert(convertFunction) : undefined,
+            approvalAmounts: this.approvalAmounts ? this.approvalAmounts.convert(convertFunction) : undefined,
+            maxNumTransfers: this.maxNumTransfers ? this.maxNumTransfers.convert(convertFunction) : undefined,
+            requireToEqualsInitiatedBy: this.requireToEqualsInitiatedBy,
+            requireFromEqualsInitiatedBy: this.requireFromEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: this.requireToDoesNotEqualInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: this.requireFromDoesNotEqualInitiatedBy,
+            overridesFromOutgoingApprovals: this.overridesFromOutgoingApprovals,
+            overridesToIncomingApprovals: this.overridesToIncomingApprovals
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.ApprovalCriteria(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ApprovalCriteria.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ApprovalCriteria.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new ApprovalCriteria({
+            mustOwnBadges: item.mustOwnBadges.map(x => typeUtils_1.MustOwnBadges.convertFromProto(x, convertFunction)),
+            merkleChallenge: item.merkleChallenge ? typeUtils_1.MerkleChallenge.convertFromProto(item.merkleChallenge, convertFunction) : undefined,
+            predeterminedBalances: item.predeterminedBalances ? PredeterminedBalances.convertFromProto(item.predeterminedBalances, convertFunction) : undefined,
+            approvalAmounts: item.approvalAmounts ? ApprovalAmounts.convertFromProto(item.approvalAmounts, convertFunction) : undefined,
+            maxNumTransfers: item.maxNumTransfers ? MaxNumTransfers.convertFromProto(item.maxNumTransfers, convertFunction) : undefined,
+            requireToEqualsInitiatedBy: item.requireToEqualsInitiatedBy,
+            requireFromEqualsInitiatedBy: item.requireFromEqualsInitiatedBy,
+            requireToDoesNotEqualInitiatedBy: item.requireToDoesNotEqualInitiatedBy,
+            requireFromDoesNotEqualInitiatedBy: item.requireFromDoesNotEqualInitiatedBy,
+            overridesFromOutgoingApprovals: item.overridesFromOutgoingApprovals,
+            overridesToIncomingApprovals: item.overridesToIncomingApprovals
+        });
+    }
+}
+exports.ApprovalCriteria = ApprovalCriteria;
+//# sourceMappingURL=approvals.js.map