bitbadgesjs-sdk 0.0.6 → 0.1.0

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

@@ -0,0 +1,1086 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsArchivedTimeline = exports.StandardsTimeline = exports.CustomDataTimeline = exports.OffChainBalancesMetadataTimeline = exports.BadgeMetadataTimeline = exports.CollectionMetadataTimeline = exports.ManagerTimeline = exports.TimelineItem = exports.MerkleProof = exports.MerklePathItem = exports.MerkleChallenge = exports.AmountTrackerIdDetails = exports.ApprovalIdentifierDetails = exports.Transfer = exports.AddressList = exports.Balance = exports.MustOwnBadges = exports.OffChainBalancesMetadata = exports.CollectionMetadata = exports.BadgeMetadata = exports.UintRange = exports.BaseNumberTypeClass = exports.CustomTypeClass = exports.compareCustomTypes = exports.compareNumberTypeConvertibles = exports.deepCopy = exports.compareObjects = void 0;
+const __1 = require("../../..");
+const string_numbers_1 = require("../string-numbers");
+function compareObjects(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (typeof obj1 !== typeof obj2 || typeof obj1 !== 'object' || obj1 === null || obj2 === null) {
+        return false;
+    }
+    if (Array.isArray(obj1) !== Array.isArray(obj2)) {
+        return false;
+    }
+    if (Array.isArray(obj1)) {
+        if (obj1.length !== obj2.length) {
+            return false;
+        }
+        for (let i = 0; i < obj1.length; i++) {
+            if (!compareObjects(obj1[i], obj2[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (const key of keys1) {
+            if (!obj2.hasOwnProperty(key) || !compareObjects(obj1[key], obj2[key])) {
+                return false;
+            }
+        }
+    }
+    if (typeof obj1 === 'bigint' || typeof obj2 === 'bigint') {
+        return BigInt(obj1) === BigInt(obj2);
+    }
+    return true;
+}
+exports.compareObjects = compareObjects;
+function deepCopy(obj) {
+    return deepCopyWithBigInts(obj);
+}
+exports.deepCopy = deepCopy;
+function deepCopyWithBigInts(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    if (typeof obj === 'bigint') {
+        return BigInt(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepCopyWithBigInts(item));
+    }
+    const copiedObj = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            copiedObj[key] = deepCopyWithBigInts(obj[key]);
+        }
+    }
+    return copiedObj;
+}
+function compareNumberTypeConvertibles(obj1, obj2, normalizeNumberTypes) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 === undefined || obj1 === null || obj2 === undefined || obj2 === null) {
+        return false;
+    }
+    if (normalizeNumberTypes) {
+        return compareObjects(obj1.convert(string_numbers_1.BigIntify).toJson(), obj2.convert(string_numbers_1.BigIntify).toJson());
+    }
+    else {
+        return compareObjects(obj1.toJson(), obj2.toJson());
+    }
+}
+exports.compareNumberTypeConvertibles = compareNumberTypeConvertibles;
+function compareCustomTypes(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 === undefined || obj1 === null || obj2 === undefined || obj2 === null) {
+        return false;
+    }
+    return compareObjects(obj1.toJson(), obj2.toJson());
+}
+exports.compareCustomTypes = compareCustomTypes;
+class CustomTypeClass {
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other) {
+        return compareCustomTypes(this, other);
+    }
+}
+exports.CustomTypeClass = CustomTypeClass;
+class BaseNumberTypeClass {
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+    convert(convertFunction) {
+        throw new Error('Method not implemented. Must be implemented in the child interface.');
+    }
+}
+exports.BaseNumberTypeClass = BaseNumberTypeClass;
+class UintRange extends BaseNumberTypeClass {
+    start;
+    end;
+    constructor(uintRange) {
+        super();
+        this.start = uintRange.start;
+        this.end = uintRange.end;
+    }
+    static required() {
+        return new UintRange({
+            start: 0,
+            end: 0
+        });
+    }
+    convert(convertFunction) {
+        return new UintRange(deepCopy({
+            start: convertFunction(this.start),
+            end: convertFunction(this.end)
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.UintRange(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UintRange.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.UintRange.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new UintRange({
+            start: convertFunction(BigInt(item.start)),
+            end: convertFunction(BigInt(item.end))
+        });
+    }
+    size() {
+        const diff = (0, __1.safeSubtractUints)(this.end, this.start);
+        return (0, __1.safeAddKeepLeft)(diff, 1);
+    }
+    isFull() {
+        return BigInt(this.start) == 1n && BigInt(this.end) == __1.GO_MAX_UINT_64;
+    }
+    static FullRange() {
+        return new UintRange({
+            start: 1n,
+            end: __1.GO_MAX_UINT_64
+        });
+    }
+    overlaps(other) {
+        const otherArr = Array.isArray(other) ? other : [other];
+        try {
+            (0, __1.assertRangesDoNotOverlapAtAll)([this.convert(string_numbers_1.BigIntify)], [...otherArr.map((o) => o.convert(string_numbers_1.BigIntify))]);
+        }
+        catch (e) {
+            return true;
+        }
+        return false;
+    }
+    invert(minId = 1n, maxId = __1.GO_MAX_UINT_64) {
+        return (0, __1.invertUintRanges)([this.convert(string_numbers_1.BigIntify)], minId, maxId);
+    }
+    includes(id) {
+        return this.start <= id && this.end >= id;
+    }
+}
+exports.UintRange = UintRange;
+class BadgeMetadata extends BaseNumberTypeClass {
+    uri;
+    badgeIds;
+    customData;
+    constructor(badgeMetadata) {
+        super();
+        this.uri = badgeMetadata.uri;
+        this.badgeIds = badgeMetadata.badgeIds.map((b) => new UintRange(b));
+        this.customData = badgeMetadata.customData;
+    }
+    static required() {
+        return new BadgeMetadata({
+            uri: '',
+            badgeIds: [],
+            customData: ''
+        });
+    }
+    convert(convertFunction) {
+        return new BadgeMetadata(deepCopy({
+            uri: this.uri,
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            customData: this.customData
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.BadgeMetadata({
+            uri: this.uri,
+            badgeIds: this.badgeIds.map((b) => b.toProto()),
+            customData: this.customData
+        });
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.BadgeMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.BadgeMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new BadgeMetadata({
+            uri: item.uri,
+            badgeIds: item.badgeIds.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            customData: item.customData
+        });
+    }
+}
+exports.BadgeMetadata = BadgeMetadata;
+class CollectionMetadata extends CustomTypeClass {
+    uri;
+    customData;
+    constructor(collectionMetadata) {
+        super();
+        this.uri = collectionMetadata.uri;
+        this.customData = collectionMetadata.customData;
+    }
+    static required() {
+        return new CollectionMetadata({
+            uri: '',
+            customData: ''
+        });
+    }
+    toProto() {
+        return new __1.proto.badges.CollectionMetadata({
+            uri: this.uri,
+            customData: this.customData
+        });
+    }
+    clone() {
+        return new CollectionMetadata({ uri: this.uri, customData: this.customData });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CollectionMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CollectionMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new CollectionMetadata({
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.CollectionMetadata = CollectionMetadata;
+class OffChainBalancesMetadata extends CustomTypeClass {
+    uri;
+    customData;
+    constructor(offChainBalancesMetadata) {
+        super();
+        this.uri = offChainBalancesMetadata.uri;
+        this.customData = offChainBalancesMetadata.customData;
+    }
+    static required() {
+        return new OffChainBalancesMetadata({
+            uri: '',
+            customData: ''
+        });
+    }
+    toProto() {
+        return new __1.proto.badges.OffChainBalancesMetadata({
+            uri: this.uri,
+            customData: this.customData
+        });
+    }
+    clone() {
+        return new OffChainBalancesMetadata({ uri: this.uri, customData: this.customData });
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.OffChainBalancesMetadata.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.OffChainBalancesMetadata.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new OffChainBalancesMetadata({
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.OffChainBalancesMetadata = OffChainBalancesMetadata;
+class MustOwnBadges extends BaseNumberTypeClass {
+    collectionId;
+    amountRange;
+    ownershipTimes;
+    badgeIds;
+    overrideWithCurrentTime;
+    mustSatisfyForAllAssets;
+    constructor(mustOwn) {
+        super();
+        this.collectionId = mustOwn.collectionId;
+        this.amountRange = new UintRange(mustOwn.amountRange);
+        this.ownershipTimes = mustOwn.ownershipTimes.map((b) => new UintRange(b));
+        this.badgeIds = mustOwn.badgeIds.map((b) => new UintRange(b));
+        this.overrideWithCurrentTime = mustOwn.overrideWithCurrentTime;
+        this.mustSatisfyForAllAssets = mustOwn.mustSatisfyForAllAssets;
+    }
+    static required() {
+        return new MustOwnBadges({
+            collectionId: 0,
+            amountRange: UintRange.required(),
+            ownershipTimes: [],
+            badgeIds: [],
+            overrideWithCurrentTime: false,
+            mustSatisfyForAllAssets: false
+        });
+    }
+    convert(convertFunction) {
+        return new MustOwnBadges(deepCopy({
+            collectionId: convertFunction(this.collectionId),
+            amountRange: this.amountRange.convert(convertFunction),
+            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction)),
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            overrideWithCurrentTime: this.overrideWithCurrentTime,
+            mustSatisfyForAllAssets: this.mustSatisfyForAllAssets
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.MustOwnBadges(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.MustOwnBadges.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.MustOwnBadges.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        if (!item.amountRange) {
+            throw new Error('amountRange is required');
+        }
+        return new MustOwnBadges({
+            collectionId: convertFunction(BigInt(item.collectionId)),
+            amountRange: UintRange.convertFromProto(item.amountRange, convertFunction),
+            ownershipTimes: item.ownershipTimes.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            badgeIds: item.badgeIds.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            overrideWithCurrentTime: item.overrideWithCurrentTime,
+            mustSatisfyForAllAssets: item.mustSatisfyForAllAssets
+        });
+    }
+}
+exports.MustOwnBadges = MustOwnBadges;
+class Balance extends BaseNumberTypeClass {
+    amount;
+    badgeIds;
+    ownershipTimes;
+    constructor(balance) {
+        super();
+        this.amount = balance.amount;
+        this.badgeIds = balance.badgeIds.map((b) => new UintRange(b));
+        this.ownershipTimes = balance.ownershipTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new Balance({
+            amount: 0,
+            badgeIds: [],
+            ownershipTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new Balance(deepCopy({
+            amount: convertFunction(this.amount),
+            badgeIds: this.badgeIds.map((b) => b.convert(convertFunction)),
+            ownershipTimes: this.ownershipTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.Balance(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.Balance.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.Balance.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new Balance({
+            amount: convertFunction(BigInt(item.amount)),
+            badgeIds: item.badgeIds.map((b) => UintRange.convertFromProto(b, convertFunction)),
+            ownershipTimes: item.ownershipTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.Balance = Balance;
+class AddressList extends CustomTypeClass {
+    listId;
+    addresses;
+    whitelist;
+    uri;
+    customData;
+    createdBy;
+    aliasAddress;
+    constructor(addressList) {
+        super();
+        this.listId = addressList.listId;
+        this.addresses = addressList.addresses;
+        this.whitelist = addressList.whitelist;
+        this.uri = addressList.uri;
+        this.customData = addressList.customData;
+        this.createdBy = addressList.createdBy;
+        this.aliasAddress = addressList.aliasAddress;
+    }
+    static required() {
+        return new AddressList({
+            listId: '',
+            addresses: [],
+            whitelist: false,
+            uri: '',
+            customData: ''
+        });
+    }
+    addDefaults() {
+        this.createdBy = this.createdBy ? this.createdBy : '';
+        this.aliasAddress = this.aliasAddress ? this.aliasAddress : '';
+    }
+    toProto() {
+        return new __1.proto.badges.AddressList(this.clone().toJson());
+    }
+    clone() {
+        return new AddressList({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(__1.proto.badges.AddressList.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(__1.proto.badges.AddressList.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new AddressList({ ...item });
+    }
+    checkAddress(address) {
+        let found = this.addresses.includes(address);
+        if (!this.whitelist) {
+            found = !found;
+        }
+        return found;
+    }
+    isEmpty() {
+        return this.addresses.length === 0 && this.whitelist;
+    }
+    invert() {
+        this.whitelist = !this.whitelist;
+    }
+    removeAddress(address) {
+        const addressListToRemove = new AddressList({
+            listId: '',
+            addresses: [address],
+            whitelist: true,
+            uri: '',
+            customData: '',
+            createdBy: '',
+        });
+        const [remaining] = (0, __1.removeAddressListFromAddressList)(addressListToRemove, this);
+        this.addresses = remaining.addresses;
+        this.whitelist = remaining.whitelist;
+    }
+    removeAddressList(addressListToRemove) {
+        const [remaining] = (0, __1.removeAddressListFromAddressList)(addressListToRemove, this);
+        this.addresses = remaining.addresses;
+        this.whitelist = remaining.whitelist;
+    }
+    getOverlappingAddresses(addressList) {
+        const [, removed] = (0, __1.removeAddressListFromAddressList)(addressList, this);
+        return removed;
+    }
+    static AllAddresses() {
+        return (0, __1.getReservedAddressList)('All');
+    }
+}
+exports.AddressList = AddressList;
+class Transfer extends BaseNumberTypeClass {
+    from;
+    toAddresses;
+    balances;
+    precalculateBalancesFromApproval;
+    merkleProofs;
+    memo;
+    prioritizedApprovals;
+    onlyCheckPrioritizedApprovals;
+    constructor(transfer) {
+        super();
+        this.from = transfer.from;
+        this.toAddresses = transfer.toAddresses;
+        this.balances = transfer.balances;
+        this.precalculateBalancesFromApproval = transfer.precalculateBalancesFromApproval;
+        this.merkleProofs = transfer.merkleProofs;
+        this.memo = transfer.memo;
+        this.prioritizedApprovals = transfer.prioritizedApprovals;
+        this.onlyCheckPrioritizedApprovals = transfer.onlyCheckPrioritizedApprovals;
+    }
+    static required() {
+        return new Transfer({
+            from: '',
+            toAddresses: [],
+            balances: [],
+            precalculateBalancesFromApproval: ApprovalIdentifierDetails.required(),
+            merkleProofs: [],
+            memo: '',
+            prioritizedApprovals: [],
+            onlyCheckPrioritizedApprovals: false
+        });
+    }
+    addDefaults() {
+        this.precalculateBalancesFromApproval = this.precalculateBalancesFromApproval ? this.precalculateBalancesFromApproval : ApprovalIdentifierDetails.required();
+        this.merkleProofs = this.merkleProofs ? this.merkleProofs : [];
+        this.memo = this.memo ? this.memo : '';
+        this.prioritizedApprovals = this.prioritizedApprovals ? this.prioritizedApprovals : [];
+        this.onlyCheckPrioritizedApprovals = this.onlyCheckPrioritizedApprovals ? this.onlyCheckPrioritizedApprovals : false;
+    }
+    convert(convertFunction) {
+        return new Transfer(deepCopy({
+            from: this.from,
+            toAddresses: this.toAddresses,
+            balances: this.balances.map((b) => b.convert(convertFunction)),
+            precalculateBalancesFromApproval: this.precalculateBalancesFromApproval ? this.precalculateBalancesFromApproval : undefined,
+            merkleProofs: this.merkleProofs ? this.merkleProofs : undefined,
+            memo: this.memo ? this.memo : undefined,
+            prioritizedApprovals: this.prioritizedApprovals ? this.prioritizedApprovals : undefined,
+            onlyCheckPrioritizedApprovals: this.onlyCheckPrioritizedApprovals ? this.onlyCheckPrioritizedApprovals : undefined
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.Transfer(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.Transfer.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.Transfer.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new Transfer({
+            from: item.from,
+            toAddresses: item.toAddresses,
+            balances: item.balances.map((b) => Balance.convertFromProto(b, convertFunction)),
+            precalculateBalancesFromApproval: item.precalculateBalancesFromApproval ? ApprovalIdentifierDetails.convertFromProto(item.precalculateBalancesFromApproval) : undefined,
+            merkleProofs: item.merkleProofs ? item.merkleProofs.map((b) => MerkleProof.convertFromProto(b)) : undefined,
+            memo: item.memo ? item.memo : undefined,
+            prioritizedApprovals: item.prioritizedApprovals ? item.prioritizedApprovals.map((b) => ApprovalIdentifierDetails.convertFromProto(b)) : undefined,
+            onlyCheckPrioritizedApprovals: item.onlyCheckPrioritizedApprovals ? item.onlyCheckPrioritizedApprovals : undefined
+        });
+    }
+}
+exports.Transfer = Transfer;
+class ApprovalIdentifierDetails extends CustomTypeClass {
+    approvalId;
+    approvalLevel;
+    approverAddress;
+    constructor(approvalIdDetails) {
+        super();
+        this.approvalId = approvalIdDetails.approvalId;
+        this.approvalLevel = approvalIdDetails.approvalLevel;
+        this.approverAddress = approvalIdDetails.approverAddress;
+    }
+    static required() {
+        return new ApprovalIdentifierDetails({
+            approvalId: '',
+            approvalLevel: '',
+            approverAddress: ''
+        });
+    }
+    toProto() {
+        return new __1.proto.badges.ApprovalIdentifierDetails(this.clone().toJson());
+    }
+    clone() {
+        return new ApprovalIdentifierDetails({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(__1.proto.badges.ApprovalIdentifierDetails.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(__1.proto.badges.ApprovalIdentifierDetails.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new ApprovalIdentifierDetails({ ...item });
+    }
+}
+exports.ApprovalIdentifierDetails = ApprovalIdentifierDetails;
+class AmountTrackerIdDetails extends BaseNumberTypeClass {
+    collectionId;
+    amountTrackerId;
+    approvalLevel;
+    approverAddress;
+    trackerType;
+    approvedAddress;
+    constructor(approvalIdDetails) {
+        super();
+        this.collectionId = approvalIdDetails.collectionId;
+        this.amountTrackerId = approvalIdDetails.amountTrackerId;
+        this.approvalLevel = approvalIdDetails.approvalLevel;
+        this.approverAddress = approvalIdDetails.approverAddress;
+        this.trackerType = approvalIdDetails.trackerType;
+        this.approvedAddress = approvalIdDetails.approvedAddress;
+    }
+    static required() {
+        return new AmountTrackerIdDetails({
+            collectionId: 0,
+            amountTrackerId: '',
+            approvalLevel: '',
+            approverAddress: '',
+            trackerType: '',
+            approvedAddress: ''
+        });
+    }
+    convert(convertFunction) {
+        return new AmountTrackerIdDetails(deepCopy({
+            collectionId: convertFunction(this.collectionId),
+            amountTrackerId: this.amountTrackerId,
+            approvalLevel: this.approvalLevel,
+            approverAddress: this.approverAddress,
+            trackerType: this.trackerType,
+            approvedAddress: this.approvedAddress
+        }));
+    }
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+}
+exports.AmountTrackerIdDetails = AmountTrackerIdDetails;
+class MerkleChallenge extends BaseNumberTypeClass {
+    root;
+    expectedProofLength;
+    useCreatorAddressAsLeaf;
+    maxUsesPerLeaf;
+    uri;
+    customData;
+    constructor(merkleChallenge) {
+        super();
+        this.root = merkleChallenge.root;
+        this.expectedProofLength = merkleChallenge.expectedProofLength;
+        this.useCreatorAddressAsLeaf = merkleChallenge.useCreatorAddressAsLeaf;
+        this.maxUsesPerLeaf = merkleChallenge.maxUsesPerLeaf;
+        this.uri = merkleChallenge.uri;
+        this.customData = merkleChallenge.customData;
+    }
+    static required() {
+        return new MerkleChallenge({
+            root: '',
+            expectedProofLength: 0,
+            useCreatorAddressAsLeaf: false,
+            maxUsesPerLeaf: 0,
+            uri: '',
+            customData: ''
+        });
+    }
+    convert(convertFunction) {
+        return new MerkleChallenge(deepCopy({
+            root: this.root,
+            expectedProofLength: convertFunction(this.expectedProofLength),
+            useCreatorAddressAsLeaf: this.useCreatorAddressAsLeaf,
+            maxUsesPerLeaf: convertFunction(this.maxUsesPerLeaf),
+            uri: this.uri,
+            customData: this.customData
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.MerkleChallenge(this.convert(string_numbers_1.Stringify));
+    }
+    toJson() {
+        return (0, __1.convertClassPropertiesToJson)(this);
+    }
+    toJsonString() {
+        return JSON.stringify(this.toJson());
+    }
+    equals(other, normalizeNumberTypes) {
+        return compareNumberTypeConvertibles(this, other, normalizeNumberTypes);
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.MerkleChallenge.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.MerkleChallenge.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new MerkleChallenge({
+            root: item.root,
+            expectedProofLength: convertFunction(BigInt(item.expectedProofLength)),
+            useCreatorAddressAsLeaf: item.useCreatorAddressAsLeaf,
+            maxUsesPerLeaf: convertFunction(BigInt(item.maxUsesPerLeaf)),
+            uri: item.uri,
+            customData: item.customData
+        });
+    }
+}
+exports.MerkleChallenge = MerkleChallenge;
+class MerklePathItem extends CustomTypeClass {
+    aunt;
+    onRight;
+    constructor(merklePathItem) {
+        super();
+        this.aunt = merklePathItem.aunt;
+        this.onRight = merklePathItem.onRight;
+    }
+    static required() {
+        return new MerklePathItem({
+            aunt: '',
+            onRight: false
+        });
+    }
+    toProto() {
+        return new __1.proto.badges.MerklePathItem(this.clone().toJson());
+    }
+    clone() {
+        return new MerklePathItem({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(__1.proto.badges.MerklePathItem.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(__1.proto.badges.MerklePathItem.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new MerklePathItem({ ...item });
+    }
+}
+exports.MerklePathItem = MerklePathItem;
+class MerkleProof extends CustomTypeClass {
+    aunts;
+    leaf;
+    constructor(merkleProof) {
+        super();
+        this.aunts = merkleProof.aunts;
+        this.leaf = merkleProof.leaf;
+    }
+    static required() {
+        return new MerkleProof({
+            aunts: [],
+            leaf: ''
+        });
+    }
+    toProto() {
+        return new __1.proto.badges.MerkleProof(this.clone().toJson());
+    }
+    clone() {
+        return new MerkleProof({ ...this });
+    }
+    static fromJson(jsonValue, options) {
+        return this.convertFromProto(__1.proto.badges.MerkleProof.fromJson(jsonValue, options));
+    }
+    static fromJsonString(jsonString, options) {
+        return this.convertFromProto(__1.proto.badges.MerkleProof.fromJsonString(jsonString, options));
+    }
+    static convertFromProto(item) {
+        return new MerkleProof({
+            aunts: item.aunts.map((b) => MerklePathItem.convertFromProto(b)),
+            leaf: item.leaf
+        });
+    }
+}
+exports.MerkleProof = MerkleProof;
+class TimelineItem extends BaseNumberTypeClass {
+    timelineTimes;
+    constructor(timelineItem) {
+        super();
+        this.timelineTimes = timelineItem.timelineTimes.map((b) => new UintRange(b));
+    }
+    convert(convertFunction) {
+        return new TimelineItem(deepCopy({
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+}
+exports.TimelineItem = TimelineItem;
+class ManagerTimeline extends BaseNumberTypeClass {
+    manager;
+    timelineTimes;
+    constructor(managerTimeline) {
+        super();
+        this.manager = managerTimeline.manager;
+        this.timelineTimes = managerTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new ManagerTimeline({
+            manager: '',
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new ManagerTimeline(deepCopy({
+            manager: this.manager,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.ManagerTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ManagerTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.ManagerTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new ManagerTimeline({
+            manager: item.manager,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.ManagerTimeline = ManagerTimeline;
+class CollectionMetadataTimeline extends BaseNumberTypeClass {
+    collectionMetadata;
+    timelineTimes;
+    constructor(collectionMetadataTimeline) {
+        super();
+        this.collectionMetadata = new CollectionMetadata(collectionMetadataTimeline.collectionMetadata);
+        this.timelineTimes = collectionMetadataTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new CollectionMetadataTimeline({
+            collectionMetadata: CollectionMetadata.required(),
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new CollectionMetadataTimeline(deepCopy({
+            collectionMetadata: this.collectionMetadata,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.CollectionMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CollectionMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CollectionMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        if (item.collectionMetadata === undefined) {
+            throw new Error('CollectionMetadataTimeline: invalid collectionMetadata');
+        }
+        return new CollectionMetadataTimeline({
+            collectionMetadata: CollectionMetadata.convertFromProto(item.collectionMetadata, convertFunction),
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.CollectionMetadataTimeline = CollectionMetadataTimeline;
+class BadgeMetadataTimeline extends BaseNumberTypeClass {
+    badgeMetadata;
+    timelineTimes;
+    constructor(badgeMetadataTimeline) {
+        super();
+        this.timelineTimes = badgeMetadataTimeline.timelineTimes.map((b) => new UintRange(b));
+        this.badgeMetadata = badgeMetadataTimeline.badgeMetadata.map((b) => new BadgeMetadata(b));
+    }
+    static required() {
+        return new BadgeMetadataTimeline({
+            badgeMetadata: [],
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new BadgeMetadataTimeline(deepCopy({
+            badgeMetadata: this.badgeMetadata.map((b) => b.convert(convertFunction)),
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.BadgeMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.BadgeMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.BadgeMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new BadgeMetadataTimeline({
+            badgeMetadata: item.badgeMetadata.map((b) => BadgeMetadata.convertFromProto(b, convertFunction)),
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.BadgeMetadataTimeline = BadgeMetadataTimeline;
+class OffChainBalancesMetadataTimeline extends BaseNumberTypeClass {
+    offChainBalancesMetadata;
+    timelineTimes;
+    constructor(offChainBalancesMetadataTimeline) {
+        super();
+        this.offChainBalancesMetadata = new OffChainBalancesMetadata(offChainBalancesMetadataTimeline.offChainBalancesMetadata);
+        this.timelineTimes = offChainBalancesMetadataTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new OffChainBalancesMetadataTimeline({
+            offChainBalancesMetadata: OffChainBalancesMetadata.required(),
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new OffChainBalancesMetadataTimeline(deepCopy({
+            offChainBalancesMetadata: this.offChainBalancesMetadata,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.OffChainBalancesMetadataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.OffChainBalancesMetadataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.OffChainBalancesMetadataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        if (!item.offChainBalancesMetadata) {
+            throw new Error("OffChainBalancesMetadataTimeline: offChainBalancesMetadata is required");
+        }
+        return new OffChainBalancesMetadataTimeline({
+            offChainBalancesMetadata: OffChainBalancesMetadata.convertFromProto(item.offChainBalancesMetadata, convertFunction),
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.OffChainBalancesMetadataTimeline = OffChainBalancesMetadataTimeline;
+class CustomDataTimeline extends BaseNumberTypeClass {
+    customData;
+    timelineTimes;
+    constructor(customDataTimeline) {
+        super();
+        this.customData = customDataTimeline.customData;
+        this.timelineTimes = customDataTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new CustomDataTimeline({
+            customData: '',
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new CustomDataTimeline(deepCopy({
+            customData: this.customData,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.CustomDataTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CustomDataTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.CustomDataTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new CustomDataTimeline({
+            customData: item.customData,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.CustomDataTimeline = CustomDataTimeline;
+class StandardsTimeline extends BaseNumberTypeClass {
+    standards;
+    timelineTimes;
+    constructor(standardsTimeline) {
+        super();
+        this.standards = standardsTimeline.standards;
+        this.timelineTimes = standardsTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new StandardsTimeline({
+            standards: [],
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new StandardsTimeline(deepCopy({
+            standards: this.standards,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.StandardsTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.StandardsTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.StandardsTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new StandardsTimeline({
+            standards: item.standards,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.StandardsTimeline = StandardsTimeline;
+class IsArchivedTimeline extends BaseNumberTypeClass {
+    isArchived;
+    timelineTimes;
+    constructor(isArchivedTimeline) {
+        super();
+        this.isArchived = isArchivedTimeline.isArchived;
+        this.timelineTimes = isArchivedTimeline.timelineTimes.map((b) => new UintRange(b));
+    }
+    static required() {
+        return new IsArchivedTimeline({
+            isArchived: false,
+            timelineTimes: []
+        });
+    }
+    convert(convertFunction) {
+        return new IsArchivedTimeline(deepCopy({
+            isArchived: this.isArchived,
+            timelineTimes: this.timelineTimes.map((b) => b.convert(convertFunction))
+        }));
+    }
+    toProto() {
+        return new __1.proto.badges.IsArchivedTimeline(this.convert(string_numbers_1.Stringify));
+    }
+    static fromJson(jsonValue, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.IsArchivedTimeline.fromJson(jsonValue, options), convertFunction);
+    }
+    static fromJsonString(jsonString, convertFunction, options) {
+        return this.convertFromProto(__1.proto.badges.IsArchivedTimeline.fromJsonString(jsonString, options), convertFunction);
+    }
+    static convertFromProto(item, convertFunction) {
+        return new IsArchivedTimeline({
+            isArchived: item.isArchived,
+            timelineTimes: item.timelineTimes.map((b) => UintRange.convertFromProto(b, convertFunction))
+        });
+    }
+}
+exports.IsArchivedTimeline = IsArchivedTimeline;
+//# sourceMappingURL=typeUtils.js.map