bitbadgesjs-sdk 0.0.7 → 0.1.1

package/dist/utils/types/db.d.ts

@@ -1,22 +1,43 @@
-import { AddressList, AmountTrackerIdDetails, BadgeMetadataTimeline, Balance, CollectionApproval, CollectionMetadataTimeline, CollectionPermissions, CustomDataTimeline, IsArchivedTimeline, ManagerTimeline, MerkleChallenge, OffChainBalancesMetadataTimeline, Protocol, StandardsTimeline, UintRange, UserBalanceStore } from "../..";
 import { ChallengeParams } from "blockin";
-import MerkleTree from "merkletreejs";
-import { Options as MerkleTreeJsOptions } from "merkletreejs/dist/MerkleTree";
-import mongoose from "mongoose";
-import { BatchBadgeDetails } from "../batch-utils";
-import { CosmosCoin } from "./coin";
-import { UserPermissionsWithDetails } from "./collections";
-import { DocsCache } from "./indexer";
+import { NumberType } from "../../types/string-numbers";
+import { CollectionApproval, UserIncomingApproval, UserIncomingApprovalWithDetails, UserOutgoingApproval, UserOutgoingApprovalWithDetails, iCollectionApproval } from "../../types/badges/approvals";
+import { BaseNumberTypeClass, CustomType, CustomTypeClass, Doc, NumberTypeConvertible } from "../../types/base";
+import { CollectionPermissions, UserPermissions, UserPermissionsWithDetails, iCollectionPermissions } from "../../types/badges/permissions";
+import { AddressList, AmountTrackerIdDetails, BadgeMetadataTimeline, Balance, CollectionMetadataTimeline, CustomDataTimeline, IsArchivedTimeline, ManagerTimeline, OffChainBalancesMetadataTimeline, StandardsTimeline, UintRange, iAddressList, iAmountTrackerIdDetails, iBadgeMetadataTimeline, iBalance, iCollectionMetadataTimeline, iCustomDataTimeline, iIsArchivedTimeline, iManagerTimeline, iOffChainBalancesMetadataTimeline, iStandardsTimeline } from "../../types/badges/typeUtils";
+import { iProtocol } from "../../types/protocols/types";
+import { BatchBadgeDetails, iBatchBadgeDetails } from "../batch-utils";
+import { CosmosCoin, iCosmosCoin } from "./coin";
+import { ApprovalInfoDetails, ChallengeDetails, iChallengeDetails } from "./collections";
 import { Metadata } from "./metadata";
-import { JSPrimitiveNumberType, NumberType } from "../..";
 import { OffChainBalancesMap } from "./transfers";
-import { SupportedChain } from "./types";
-import { UserIncomingApprovalWithDetails, UserOutgoingApprovalWithDetails } from "./users";
-export interface Doc {
+import { SupportedChain } from "../../types/types";
+import { UserBalanceStore, iUserBalanceStore } from "../../types/badges/userBalances";
+export interface iCollectionDoc<T extends NumberType> extends Doc {
+    collectionId: T;
+    collectionMetadataTimeline: iCollectionMetadataTimeline<T>[];
+    badgeMetadataTimeline: iBadgeMetadataTimeline<T>[];
+    balancesType: "Standard" | "Off-Chain - Indexed" | "Inherited" | "Off-Chain - Non-Indexed";
+    offChainBalancesMetadataTimeline: iOffChainBalancesMetadataTimeline<T>[];
+    customDataTimeline: iCustomDataTimeline<T>[];
+    managerTimeline: iManagerTimeline<T>[];
+    collectionPermissions: iCollectionPermissions<T>;
+    collectionApprovals: iCollectionApproval<T>[];
+    standardsTimeline: iStandardsTimeline<T>[];
+    isArchivedTimeline: iIsArchivedTimeline<T>[];
+    defaultBalances: iUserBalanceStore<T>;
+    createdBy: string;
+    createdBlock: T;
+    createdTimestamp: T;
+    updateHistory: {
+        txHash: string;
+        block: T;
+        blockTimestamp: T;
+    }[];
+    aliasAddress: string;
+}
+export declare class CollectionDoc<T extends NumberType> extends BaseNumberTypeClass implements iCollectionDoc<T>, NumberTypeConvertible<CollectionDoc<T>, T> {
     _docId: string;
     _id?: string;
-}
-export interface CollectionInfoBase<T extends NumberType> {
     collectionId: T;
     collectionMetadataTimeline: CollectionMetadataTimeline<T>[];
     badgeMetadataTimeline: BadgeMetadataTimeline<T>[];
@@ -38,39 +59,106 @@ export interface CollectionInfoBase<T extends NumberType> {
         blockTimestamp: T;
     }[];
     aliasAddress: string;
+    constructor(data: iCollectionDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): CollectionDoc<U>;
 }
-export type CollectionDoc<T extends NumberType> = CollectionInfoBase<T> & Doc;
-export declare function convertCollectionDoc<T extends NumberType, U extends NumberType>(item: CollectionDoc<T>, convertFunction: (item: T) => U): CollectionDoc<U>;
-export interface AccountInfoBase<T extends NumberType> {
+export interface iAccountDoc<T extends NumberType> extends Doc {
     publicKey: string;
+    accountNumber: T;
     pubKeyType: string;
     cosmosAddress: string;
     ethAddress: string;
     solAddress: string;
     btcAddress: string;
+    sequence: T;
+    balance?: iCosmosCoin<T>;
+}
+export declare class AccountDoc<T extends NumberType> extends BaseNumberTypeClass implements iAccountDoc<T>, NumberTypeConvertible<AccountDoc<T>, T> {
+    _docId: string;
+    _id?: string;
+    publicKey: string;
     accountNumber: T;
-    sequence?: T;
+    pubKeyType: string;
+    cosmosAddress: string;
+    ethAddress: string;
+    solAddress: string;
+    btcAddress: string;
+    sequence: T;
     balance?: CosmosCoin<T>;
+    constructor(data: iAccountDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): AccountDoc<U>;
 }
-export type AccountDoc<T extends NumberType> = AccountInfoBase<T> & Doc;
-export declare function convertAccountDoc<T extends NumberType, U extends NumberType>(item: AccountDoc<T>, convertFunction: (item: T) => U): AccountDoc<U>;
 export interface CustomLink {
     title: string;
     url: string;
     image: string;
 }
-export interface CustomPage<T extends NumberType> {
+export interface iCustomPage<T extends NumberType> {
+    title: string;
+    description: string;
+    items: BatchBadgeDetails<T>[];
+}
+export declare class CustomPage<T extends NumberType> extends BaseNumberTypeClass implements iCustomPage<T>, NumberTypeConvertible<CustomPage<T>, T> {
     title: string;
     description: string;
     items: BatchBadgeDetails<T>[];
+    constructor(data: iCustomPage<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): CustomPage<U>;
 }
 export type AddressListId = string;
-export interface CustomListPage {
+export interface iCustomListPage {
     title: string;
     description: string;
     items: AddressListId[];
 }
-export interface ProfileInfoBase<T extends NumberType> {
+export declare class CustomListPage extends CustomTypeClass implements iCustomListPage, CustomType<CustomListPage> {
+    title: string;
+    description: string;
+    items: AddressListId[];
+    constructor(data: iCustomListPage);
+}
+export interface iProfileDoc<T extends NumberType> extends Doc {
+    fetchedProfile?: boolean;
+    seenActivity?: T;
+    createdAt?: T;
+    discord?: string;
+    twitter?: string;
+    github?: string;
+    telegram?: string;
+    readme?: string;
+    customLinks?: CustomLink[];
+    hiddenBadges?: iBatchBadgeDetails<T>[];
+    hiddenLists?: string[];
+    customPages?: {
+        badges: CustomPage<T>[];
+        lists: CustomListPage[];
+    };
+    watchlists?: {
+        badges: CustomPage<T>[];
+        lists: CustomListPage[];
+    };
+    profilePicUrl?: string;
+    username?: string;
+    latestSignedInChain?: SupportedChain;
+    solAddress?: string;
+    notifications?: {
+        email?: string;
+        emailVerification?: {
+            verified?: boolean;
+            token?: string;
+            expiry?: T;
+            antiPhishingCode?: string;
+        };
+        preferences?: {
+            listActivity?: boolean;
+            transferActivity?: boolean;
+            claimAlerts?: boolean;
+        };
+    };
+}
+export declare class ProfileDoc<T extends NumberType> extends BaseNumberTypeClass implements iProfileDoc<T>, NumberTypeConvertible<ProfileDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     fetchedProfile?: boolean;
     seenActivity?: T;
     createdAt?: T;
@@ -108,13 +196,27 @@ export interface ProfileInfoBase<T extends NumberType> {
             claimAlerts?: boolean;
         };
     };
+    constructor(data: iProfileDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): ProfileDoc<U>;
 }
-export type ProfileDoc<T extends NumberType> = ProfileInfoBase<T> & Doc;
-export declare function convertProfileDoc<T extends NumberType, U extends NumberType>(item: ProfileDoc<T>, convertFunction: (item: T) => U): ProfileDoc<U>;
-export interface IndexerStatus {
-    status: StatusDoc<bigint>;
+export interface iQueueDoc<T extends NumberType> extends Doc {
+    uri: string;
+    collectionId: T;
+    loadBalanceId: T;
+    refreshRequestTime: T;
+    numRetries: T;
+    lastFetchedAt?: T;
+    error?: string;
+    deletedAt?: T;
+    nextFetchTime?: T;
+    emailMessage?: string;
+    recipientAddress?: string;
+    activityDocId?: string;
+    notificationType?: string;
 }
-export interface QueueInfoBase<T extends NumberType> {
+export declare class QueueDoc<T extends NumberType> extends BaseNumberTypeClass implements iQueueDoc<T>, NumberTypeConvertible<QueueDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     uri: string;
     collectionId: T;
     loadBalanceId: T;
@@ -128,36 +230,55 @@ export interface QueueInfoBase<T extends NumberType> {
     recipientAddress?: string;
     activityDocId?: string;
     notificationType?: string;
+    constructor(data: iQueueDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): QueueDoc<U>;
+}
+export interface indexerStatus {
+    status: StatusDoc<bigint>;
 }
-export type QueueDoc<T extends NumberType> = QueueInfoBase<T> & Doc;
-export declare function convertQueueDoc<T extends NumberType, U extends NumberType>(item: QueueDoc<T>, convertFunction: (item: T) => U): QueueDoc<U>;
-export interface LatestBlockStatus<T extends NumberType> {
+export interface iLatestBlockStatus<T extends NumberType> {
     height: T;
     txIndex: T;
     timestamp: T;
 }
-export declare function convertLatestBlockStatus<T extends NumberType, U extends NumberType>(item: LatestBlockStatus<T>, convertFunction: (item: T) => U): LatestBlockStatus<U>;
-export interface StatusInfoBase<T extends NumberType> {
-    block: LatestBlockStatus<T>;
+export declare class LatestBlockStatus<T extends NumberType> extends BaseNumberTypeClass implements iLatestBlockStatus<T>, NumberTypeConvertible<LatestBlockStatus<T>, T> {
+    height: T;
+    txIndex: T;
+    timestamp: T;
+    constructor(data: iLatestBlockStatus<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): LatestBlockStatus<U>;
+}
+export interface iStatusDoc<T extends NumberType> extends Doc {
+    block: iLatestBlockStatus<T>;
     nextCollectionId: T;
     gasPrice: number;
+    lastXGasAmounts: T[];
     lastXGasLimits: T[];
+}
+export declare class StatusDoc<T extends NumberType> extends BaseNumberTypeClass implements iStatusDoc<T>, NumberTypeConvertible<StatusDoc<T>, T> {
+    _docId: string;
+    _id?: string;
+    block: LatestBlockStatus<T>;
+    nextCollectionId: T;
+    gasPrice: number;
     lastXGasAmounts: T[];
+    lastXGasLimits: T[];
+    constructor(data: iStatusDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): StatusDoc<U>;
 }
-export type StatusDoc<T extends NumberType> = StatusInfoBase<T> & Doc;
-export declare function convertStatusDoc<T extends NumberType, U extends NumberType>(item: StatusDoc<T>, convertFunction: (item: T) => U): StatusDoc<U>;
-export interface AddressListEditKey<T extends NumberType> {
+export interface iAddressListEditKey<T extends NumberType> {
     key: string;
     expirationDate: T;
     mustSignIn?: boolean;
 }
-export interface AddressListEditKeyDoc<T extends NumberType> extends AddressListEditKey<T> {
-    _docId: string;
-    _rev?: undefined;
-    _deleted?: undefined;
+export declare class AddressListEditKey<T extends NumberType> extends BaseNumberTypeClass implements iAddressListEditKey<T>, NumberTypeConvertible<AddressListEditKey<T>, T> {
+    key: string;
+    expirationDate: T;
+    mustSignIn?: boolean;
+    constructor(data: iAddressListEditKey<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): AddressListEditKey<U>;
 }
-export declare function convertAddressListEditKey<T extends NumberType, U extends NumberType>(item: AddressListEditKey<T>, convertFunction: (item: T) => U): AddressListEditKey<U>;
-export interface AddressListInfoBase<T extends NumberType> extends AddressList {
+export interface iAddressListDoc<T extends NumberType> extends iAddressList, Doc {
     createdBy: string;
     updateHistory: {
         txHash: string;
@@ -166,43 +287,122 @@ export interface AddressListInfoBase<T extends NumberType> extends AddressList {
     }[];
     createdBlock: T;
     lastUpdated: T;
+    nsfw?: {
+        reason: string;
+    };
+    reported?: {
+        reason: string;
+    };
     private?: boolean;
     viewableWithLink?: boolean;
-    editKeys?: AddressListEditKey<T>[];
+    editKeys?: iAddressListEditKey<T>[];
+}
+export declare class AddressListDoc<T extends NumberType> extends AddressList implements NumberTypeConvertible<AddressListDoc<T>, T>, iAddressListDoc<T> {
+    _docId: string;
+    _id?: string;
+    createdBy: string;
+    updateHistory: {
+        txHash: string;
+        block: T;
+        blockTimestamp: T;
+    }[];
+    createdBlock: T;
+    lastUpdated: T;
     nsfw?: {
         reason: string;
     };
     reported?: {
         reason: string;
     };
+    private?: boolean;
+    viewableWithLink?: boolean;
+    editKeys?: AddressListEditKey<T>[];
+    constructor(data: iAddressListDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): AddressListDoc<U>;
 }
-export declare function convertAddressListInfoBase<T extends NumberType, U extends NumberType>(item: AddressListInfoBase<T>, convertFunction: (item: T) => U): AddressListInfoBase<U>;
-export type AddressListDoc<T extends NumberType> = AddressListInfoBase<T> & Doc;
-export declare function convertAddressListDoc<T extends NumberType, U extends NumberType>(item: AddressListDoc<T>, convertFunction: (item: T) => U): AddressListDoc<U>;
-export interface BalanceInfoBase<T extends NumberType> extends UserBalanceStore<T> {
+export interface iBalanceDoc<T extends NumberType> extends iUserBalanceStore<T>, Doc {
     collectionId: T;
     cosmosAddress: string;
     onChain: boolean;
     uri?: string;
     fetchedAt?: T;
     fetchedAtBlock?: T;
+    isPermanent?: boolean;
     contentHash?: string;
+    updateHistory: {
+        txHash: string;
+        block: T;
+        blockTimestamp: T;
+    }[];
+}
+export declare class BalanceDoc<T extends NumberType> extends BaseNumberTypeClass implements NumberTypeConvertible<BalanceDoc<T>, T>, iBalanceDoc<T> {
+    _docId: string;
+    _id?: string;
+    collectionId: T;
+    cosmosAddress: string;
+    onChain: boolean;
+    uri?: string;
+    fetchedAt?: T;
+    fetchedAtBlock?: T;
     isPermanent?: boolean;
+    contentHash?: string;
     updateHistory: {
         txHash: string;
         block: T;
         blockTimestamp: T;
     }[];
+    balances: Balance<T>[];
+    incomingApprovals: UserIncomingApproval<T>[];
+    outgoingApprovals: UserOutgoingApproval<T>[];
+    userPermissions: UserPermissions<T>;
+    autoApproveSelfInitiatedIncomingTransfers: boolean;
+    autoApproveSelfInitiatedOutgoingTransfers: boolean;
+    constructor(data: iBalanceDoc<T> & Doc & iUserBalanceStore<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): BalanceDoc<U>;
+}
+export interface iBalanceDocWithDetails<T extends NumberType> extends iBalanceDoc<T> {
+    outgoingApprovals: UserOutgoingApprovalWithDetails<T>[];
+    incomingApprovals: UserIncomingApprovalWithDetails<T>[];
+    userPermissions: UserPermissionsWithDetails<T>;
 }
-export type BalanceDoc<T extends NumberType> = BalanceInfoBase<T> & Doc;
-export declare function convertBalanceDoc<T extends NumberType, U extends NumberType>(item: BalanceDoc<T>, convertFunction: (item: T) => U): BalanceDoc<U>;
-export interface BalanceDocWithDetails<T extends NumberType> extends BalanceDoc<T> {
+export declare class BalanceDocWithDetails<T extends NumberType> extends BaseNumberTypeClass implements NumberTypeConvertible<BalanceDocWithDetails<T>, T>, iBalanceDocWithDetails<T> {
     outgoingApprovals: UserOutgoingApprovalWithDetails<T>[];
     incomingApprovals: UserIncomingApprovalWithDetails<T>[];
     userPermissions: UserPermissionsWithDetails<T>;
+    _docId: string;
+    _id?: string;
+    collectionId: T;
+    cosmosAddress: string;
+    onChain: boolean;
+    uri?: string;
+    fetchedAt?: T;
+    fetchedAtBlock?: T;
+    isPermanent?: boolean;
+    contentHash?: string;
+    updateHistory: {
+        txHash: string;
+        block: T;
+        blockTimestamp: T;
+    }[];
+    balances: Balance<T>[];
+    autoApproveSelfInitiatedIncomingTransfers: boolean;
+    autoApproveSelfInitiatedOutgoingTransfers: boolean;
+    constructor(data: iBalanceDocWithDetails<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): BalanceDocWithDetails<U>;
 }
-export declare function convertBalanceDocWithDetails<T extends NumberType, U extends NumberType>(item: BalanceDocWithDetails<T>, convertFunction: (item: T) => U): BalanceDocWithDetails<U>;
-export interface PasswordInfoBase<T extends NumberType> {
+export interface iPasswordDoc<T extends NumberType> extends Doc {
+    cid: string;
+    createdBy: string;
+    docClaimedByCollection: boolean;
+    collectionId: T;
+    claimedUsers: {
+        [cosmosAddress: string]: T;
+    };
+    challengeDetails?: iChallengeDetails<T>;
+}
+export declare class PasswordDoc<T extends NumberType> extends BaseNumberTypeClass implements iPasswordDoc<T>, NumberTypeConvertible<PasswordDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     cid: string;
     createdBy: string;
     docClaimedByCollection: boolean;
@@ -211,100 +411,166 @@ export interface PasswordInfoBase<T extends NumberType> {
         [cosmosAddress: string]: T;
     };
     challengeDetails?: ChallengeDetails<T>;
+    constructor(data: iPasswordDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): PasswordDoc<U>;
+}
+export interface iApprovalTrackerDoc<T extends NumberType> extends iAmountTrackerIdDetails<T>, Doc {
+    numTransfers: T;
+    amounts: iBalance<T>[];
 }
-export type PasswordDoc<T extends NumberType> = PasswordInfoBase<T> & Doc;
-export declare function convertPasswordDoc<T extends NumberType, U extends NumberType>(item: PasswordDoc<T>, convertFunction: (item: T) => U): PasswordDoc<U>;
-export interface LeavesDetails {
-    leaves: string[];
-    isHashed: boolean;
-    preimages?: string[];
-}
-export interface ChallengeDetails<T extends NumberType> {
-    leavesDetails: LeavesDetails;
-    tree?: MerkleTree;
-    treeOptions?: MerkleTreeJsOptions;
-    numLeaves?: T;
-    currCode?: T;
-    hasPassword?: boolean;
-    password?: string;
-}
-export declare function convertChallengeDetails<T extends NumberType, U extends NumberType>(item: ChallengeDetails<T>, convertFunction: (item: T) => U): ChallengeDetails<U>;
-export interface ApprovalTrackerInfoBase<T extends NumberType> extends AmountTrackerIdDetails<T> {
+export declare class ApprovalTrackerDoc<T extends NumberType> extends AmountTrackerIdDetails<T> implements NumberTypeConvertible<ApprovalTrackerDoc<T>, T>, iApprovalTrackerDoc<T>, Doc {
+    _docId: string;
+    _id?: string;
     numTransfers: T;
     amounts: Balance<T>[];
+    constructor(data: iApprovalTrackerDoc<T> & Doc & iAmountTrackerIdDetails<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): ApprovalTrackerDoc<U>;
+}
+export interface iChallengeTrackerIdDetails<T extends NumberType> {
+    collectionId: T;
+    challengeId: string;
+    challengeLevel: "collection" | "incoming" | "outgoing" | "";
+    approverAddress: string;
 }
-export type ApprovalTrackerDoc<T extends NumberType> = ApprovalTrackerInfoBase<T> & Doc;
-export declare function convertApprovalTrackerDoc<T extends NumberType, U extends NumberType>(item: ApprovalTrackerDoc<T>, convertFunction: (item: T) => U): ApprovalTrackerDoc<U>;
-export interface ChallengeTrackerIdDetails<T extends NumberType> {
+export declare class ChallengeTrackerIdDetails<T extends NumberType> extends BaseNumberTypeClass implements iChallengeTrackerIdDetails<T>, NumberTypeConvertible<ChallengeTrackerIdDetails<T>, T> {
     collectionId: T;
     challengeId: string;
     challengeLevel: "collection" | "incoming" | "outgoing" | "";
     approverAddress: string;
+    constructor(data: iChallengeTrackerIdDetails<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): ChallengeTrackerIdDetails<U>;
 }
-export declare function convertChallengeTrackerIdDetails<T extends NumberType, U extends NumberType>(item: ChallengeTrackerIdDetails<T>, convertFunction: (item: T) => U): ChallengeTrackerIdDetails<U>;
-export interface MerkleChallengeInfoBase<T extends NumberType> {
+export interface iMerkleChallengeDoc<T extends NumberType> extends Doc {
     collectionId: T;
     challengeId: string;
     challengeLevel: "collection" | "incoming" | "outgoing" | "";
     approverAddress: string;
-    usedLeafIndices: (T)[];
+    usedLeafIndices: T[];
 }
-export type MerkleChallengeDoc<T extends NumberType> = MerkleChallengeInfoBase<T> & Doc;
-export declare function convertMerkleChallengeDoc<T extends NumberType, U extends NumberType>(item: MerkleChallengeDoc<T>, convertFunction: (item: T) => U): MerkleChallengeDoc<U>;
-export interface MerkleChallengeIdDetails<T extends NumberType> {
+export declare class MerkleChallengeDoc<T extends NumberType> extends BaseNumberTypeClass implements iMerkleChallengeDoc<T>, NumberTypeConvertible<MerkleChallengeDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     collectionId: T;
     challengeId: string;
     challengeLevel: "collection" | "incoming" | "outgoing" | "";
     approverAddress: string;
+    usedLeafIndices: T[];
+    constructor(data: iMerkleChallengeDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): MerkleChallengeDoc<U>;
 }
-export declare function convertMerkleChallengeIdDetails<T extends NumberType, U extends NumberType>(item: MerkleChallengeIdDetails<T>, convertFunction: (item: T) => U): MerkleChallengeIdDetails<U>;
-export interface MerkleChallengeWithDetails<T extends NumberType> extends MerkleChallenge<T> {
-    details?: ApprovalInfoDetails<T>;
+export interface iMerkleChallengeIdDetails<T extends NumberType> {
+    collectionId: T;
+    challengeId: string;
+    challengeLevel: "collection" | "incoming" | "outgoing" | "";
+    approverAddress: string;
+    usedLeafIndices: T[];
 }
-export declare function convertMerkleChallengeWithDetails<T extends NumberType, U extends NumberType>(item: MerkleChallengeWithDetails<T>, convertFunction: (item: T) => U): MerkleChallengeWithDetails<U>;
-export interface ApprovalInfoDetails<T extends NumberType> {
-    name: string;
-    description: string;
-    hasPassword?: boolean;
-    password?: string;
-    challengeDetails: ChallengeDetails<T>;
+export declare class MerkleChallengeIdDetails<T extends NumberType> extends BaseNumberTypeClass implements iMerkleChallengeIdDetails<T>, NumberTypeConvertible<MerkleChallengeIdDetails<T>, T> {
+    collectionId: T;
+    challengeId: string;
+    challengeLevel: "collection" | "incoming" | "outgoing" | "";
+    approverAddress: string;
+    usedLeafIndices: T[];
+    constructor(data: iMerkleChallengeIdDetails<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): MerkleChallengeIdDetails<U>;
 }
-export declare function convertApprovalInfoDetails<T extends NumberType, U extends NumberType>(item: ApprovalInfoDetails<T>, convertFunction: (item: T) => U): ApprovalInfoDetails<U>;
-export interface FetchInfoBase<T extends NumberType> {
+export interface iFetchDoc<T extends NumberType> extends Doc {
     content?: Metadata<T> | ApprovalInfoDetails<T> | OffChainBalancesMap<T>;
     fetchedAt: T;
     fetchedAtBlock: T;
     db: 'ApprovalInfo' | 'Metadata' | 'Balances';
     isPermanent: boolean;
 }
-export type FetchDoc<T extends NumberType> = FetchInfoBase<T> & Doc;
-export declare function convertFetchDoc<T extends NumberType, U extends NumberType>(item: FetchDoc<T>, convertFunction: (item: T) => U): FetchDoc<U>;
-export interface RefreshInfoBase<T extends NumberType> {
+export declare class FetchDoc<T extends NumberType> extends BaseNumberTypeClass implements iFetchDoc<T>, NumberTypeConvertible<FetchDoc<T>, T> {
+    _docId: string;
+    _id?: string;
+    content?: Metadata<T> | ApprovalInfoDetails<T> | OffChainBalancesMap<T>;
+    fetchedAt: T;
+    fetchedAtBlock: T;
+    db: 'ApprovalInfo' | 'Metadata' | 'Balances';
+    isPermanent: boolean;
+    constructor(data: iFetchDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): FetchDoc<U>;
+}
+export interface iRefreshDoc<T extends NumberType> extends Doc {
     collectionId: T;
     refreshRequestTime: T;
 }
-export type RefreshDoc<T extends NumberType> = RefreshInfoBase<T> & Doc;
-export declare function convertRefreshDoc<T extends NumberType, U extends NumberType>(item: RefreshDoc<T>, convertFunction: (item: T) => U): RefreshDoc<U>;
+export declare class RefreshDoc<T extends NumberType> extends BaseNumberTypeClass implements iRefreshDoc<T>, NumberTypeConvertible<RefreshDoc<T>, T> {
+    _docId: string;
+    _id?: string;
+    collectionId: T;
+    refreshRequestTime: T;
+    constructor(data: iRefreshDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): RefreshDoc<U>;
+}
 export interface ErrorDoc {
     _docId: string;
     _id?: string;
     error: string;
     function: string;
-    docs?: DocsCache;
 }
-export interface AirdropInfoBase<T extends NumberType> {
+export interface iAirdropDoc<T extends NumberType> extends Doc {
+    airdropped: boolean;
+    timestamp: T;
+    hash?: string;
+}
+export declare class AirdropDoc<T extends NumberType> extends BaseNumberTypeClass implements iAirdropDoc<T>, NumberTypeConvertible<AirdropDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     airdropped: boolean;
     timestamp: T;
     hash?: string;
+    constructor(data: iAirdropDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): AirdropDoc<U>;
+}
+export interface iIPFSTotalsDoc<T extends NumberType> extends Doc {
+    bytesUploaded: T;
 }
-export type AirdropDoc<T extends NumberType> = AirdropInfoBase<T> & Doc;
-export declare function convertAirdropDoc<T extends NumberType, U extends NumberType>(item: AirdropDoc<T>, convertFunction: (item: T) => U): AirdropDoc<U>;
-export interface IPFSTotalsInfoBase<T extends NumberType> {
+export declare class IPFSTotalsDoc<T extends NumberType> extends BaseNumberTypeClass implements iIPFSTotalsDoc<T>, NumberTypeConvertible<IPFSTotalsDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     bytesUploaded: T;
+    constructor(data: iIPFSTotalsDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): IPFSTotalsDoc<U>;
+}
+export interface iComplianceDoc<T extends NumberType> extends Doc {
+    badges: {
+        nsfw: {
+            collectionId: T;
+            badgeIds: UintRange<T>[];
+            reason: string;
+        }[];
+        reported: {
+            collectionId: T;
+            badgeIds: UintRange<T>[];
+            reason: string;
+        }[];
+    };
+    addressLists: {
+        nsfw: {
+            listId: AddressListId;
+            reason: string;
+        }[];
+        reported: {
+            listId: AddressListId;
+            reason: string;
+        }[];
+    };
+    accounts: {
+        nsfw: {
+            cosmosAddress: string;
+            reason: string;
+        }[];
+        reported: {
+            cosmosAddress: string;
+            reason: string;
+        }[];
+    };
 }
-export type IPFSTotalsDoc<T extends NumberType> = IPFSTotalsInfoBase<T> & Doc;
-export declare function convertIPFSTotalsDoc<T extends NumberType, U extends NumberType>(item: IPFSTotalsDoc<T>, convertFunction: (item: T) => U): IPFSTotalsDoc<U>;
-export interface ComplianceInfoBase<T extends NumberType> {
+export declare class ComplianceDoc<T extends NumberType> extends BaseNumberTypeClass implements iComplianceDoc<T>, NumberTypeConvertible<ComplianceDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     badges: {
         nsfw: {
             collectionId: T;
@@ -337,10 +603,22 @@ export interface ComplianceInfoBase<T extends NumberType> {
             reason: string;
         }[];
     };
+    constructor(data: iComplianceDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): ComplianceDoc<U>;
+}
+export interface iBlockinAuthSignatureDoc<T extends NumberType> extends Doc {
+    signature: string;
+    name: string;
+    description: string;
+    image: string;
+    cosmosAddress: string;
+    params: ChallengeParams<T>;
+    createdAt: T;
+    deletedAt?: T;
 }
-export type ComplianceDoc<T extends NumberType> = ComplianceInfoBase<T> & Doc;
-export declare function convertComplianceDoc<T extends NumberType, U extends NumberType>(item: ComplianceDoc<T>, convertFunction: (item: T) => U): ComplianceDoc<U>;
-export interface BlockinAuthSignatureInfoBase<T extends NumberType> {
+export declare class BlockinAuthSignatureDoc<T extends NumberType> extends BaseNumberTypeClass implements iBlockinAuthSignatureDoc<T>, NumberTypeConvertible<BlockinAuthSignatureDoc<T>, T> {
+    _docId: string;
+    _id?: string;
     signature: string;
     name: string;
     description: string;
@@ -349,123 +627,54 @@ export interface BlockinAuthSignatureInfoBase<T extends NumberType> {
     params: ChallengeParams<T>;
     createdAt: T;
     deletedAt?: T;
+    constructor(data: iBlockinAuthSignatureDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): BlockinAuthSignatureDoc<U>;
 }
-export type BlockinAuthSignatureDoc<T extends NumberType> = BlockinAuthSignatureInfoBase<T> & Doc;
-export declare function convertBlockinAuthSignatureDoc<T extends NumberType, U extends NumberType>(item: BlockinAuthSignatureDoc<T>, convertFunction: (item: T) => U): BlockinAuthSignatureDoc<U>;
-export interface FollowDetailsInfoBase<T extends NumberType> {
+export interface iFollowDetailsDoc<T extends NumberType> extends Doc {
     cosmosAddress: string;
+    followingCount: T;
+    followersCount: T;
+    followers: string[];
+    following: string[];
     followingCollectionId: T;
+}
+export declare class FollowDetailsDoc<T extends NumberType> extends BaseNumberTypeClass implements NumberTypeConvertible<FollowDetailsDoc<T>, T>, iFollowDetailsDoc<T> {
+    _docId: string;
+    _id?: string;
+    cosmosAddress: string;
     followingCount: T;
     followersCount: T;
     followers: string[];
     following: string[];
+    followingCollectionId: T;
+    constructor(data: iFollowDetailsDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): FollowDetailsDoc<U>;
 }
-export type FollowDetailsDoc<T extends NumberType> = FollowDetailsInfoBase<T> & Doc;
-export declare function convertFollowDetailsDoc<T extends NumberType, U extends NumberType>(item: FollowDetailsDoc<T>, convertFunction: (item: T) => U): FollowDetailsDoc<U>;
-export interface ProtocolInfoBase<T extends NumberType> extends Protocol {
+export interface iProtocolDoc<T extends NumberType> extends iProtocol, Doc {
 }
-export type ProtocolDoc<T extends NumberType> = ProtocolInfoBase<T> & Doc;
-export declare function convertProtocolDoc<T extends NumberType, U extends NumberType>(item: ProtocolDoc<T>, convertFunction: (item: T) => U): ProtocolDoc<U>;
-export interface UserProtocolCollectionsInfoBase<T extends NumberType> {
+export declare class ProtocolDoc<T extends NumberType> extends BaseNumberTypeClass implements NumberTypeConvertible<ProtocolDoc<T>, T>, iProtocolDoc<T> {
+    _docId: string;
+    _id?: string;
+    name: string;
+    uri: string;
+    customData: string;
+    createdBy: string;
+    isFrozen: boolean;
+    constructor(data: iProtocolDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): ProtocolDoc<U>;
+}
+export interface iUserProtocolCollectionsDoc<T extends NumberType> extends Doc {
+    protocols: {
+        [protocolName: string]: T;
+    };
+}
+export declare class UserProtocolCollectionsDoc<T extends NumberType> extends BaseNumberTypeClass implements NumberTypeConvertible<UserProtocolCollectionsDoc<T>, T>, iUserProtocolCollectionsDoc<T> {
+    _docId: string;
+    _id?: string;
     protocols: {
         [protocolName: string]: T;
     };
+    constructor(data: iUserProtocolCollectionsDoc<T>);
+    convert<U extends NumberType>(convertFunction: (item: NumberType) => U): UserProtocolCollectionsDoc<U>;
 }
-export type UserProtocolCollectionsDoc<T extends NumberType> = UserProtocolCollectionsInfoBase<T> & Doc;
-export declare function convertUserProtocolCollectionsDoc<T extends NumberType, U extends NumberType>(item: UserProtocolCollectionsDoc<T>, convertFunction: (item: T) => U): UserProtocolCollectionsDoc<U>;
-export declare const ProtocolSchema: mongoose.Schema<ProtocolDoc<JSPrimitiveNumberType>, mongoose.Model<ProtocolDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, ProtocolDoc<JSPrimitiveNumberType>> & ProtocolInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ProtocolDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<ProtocolDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<ProtocolDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const UserProtocolCollectionsSchema: mongoose.Schema<UserProtocolCollectionsDoc<JSPrimitiveNumberType>, mongoose.Model<UserProtocolCollectionsDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, UserProtocolCollectionsDoc<JSPrimitiveNumberType>> & UserProtocolCollectionsInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, UserProtocolCollectionsDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<UserProtocolCollectionsDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<UserProtocolCollectionsDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const CollectionSchema: mongoose.Schema<CollectionDoc<JSPrimitiveNumberType>, mongoose.Model<CollectionDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, CollectionDoc<JSPrimitiveNumberType>> & CollectionInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, CollectionDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<CollectionDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<CollectionDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const AccountSchema: mongoose.Schema<AccountDoc<JSPrimitiveNumberType>, mongoose.Model<AccountDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, AccountDoc<JSPrimitiveNumberType>> & AccountInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, AccountDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<AccountDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<AccountDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const ProfileSchema: mongoose.Schema<ProfileDoc<JSPrimitiveNumberType>, mongoose.Model<ProfileDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, ProfileDoc<JSPrimitiveNumberType>> & ProfileInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ProfileDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<ProfileDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<ProfileDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const QueueSchema: mongoose.Schema<QueueDoc<JSPrimitiveNumberType>, mongoose.Model<QueueDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, QueueDoc<JSPrimitiveNumberType>> & QueueInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, QueueDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<QueueDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<QueueDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const StatusSchema: mongoose.Schema<StatusDoc<JSPrimitiveNumberType>, mongoose.Model<StatusDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, StatusDoc<JSPrimitiveNumberType>> & StatusInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, StatusDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<StatusDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<StatusDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const AddressListSchema: mongoose.Schema<AddressListDoc<JSPrimitiveNumberType>, mongoose.Model<AddressListDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, AddressListDoc<JSPrimitiveNumberType>> & AddressListInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, AddressListDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<AddressListDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<AddressListDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const BalanceSchema: mongoose.Schema<BalanceDoc<JSPrimitiveNumberType>, mongoose.Model<BalanceDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, BalanceDoc<JSPrimitiveNumberType>> & BalanceInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, BalanceDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<BalanceDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<BalanceDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const PasswordSchema: mongoose.Schema<PasswordDoc<JSPrimitiveNumberType>, mongoose.Model<PasswordDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, PasswordDoc<JSPrimitiveNumberType>> & PasswordInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, PasswordDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<PasswordDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<PasswordDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const ChallengeSchema: mongoose.Schema<MerkleChallengeDoc<JSPrimitiveNumberType>, mongoose.Model<MerkleChallengeDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, MerkleChallengeDoc<JSPrimitiveNumberType>> & MerkleChallengeInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, MerkleChallengeDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<MerkleChallengeDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<MerkleChallengeDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const ApprovalTrackerSchema: mongoose.Schema<ApprovalTrackerDoc<JSPrimitiveNumberType>, mongoose.Model<ApprovalTrackerDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, ApprovalTrackerDoc<JSPrimitiveNumberType>> & ApprovalTrackerInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ApprovalTrackerDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<ApprovalTrackerDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<ApprovalTrackerDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const FetchSchema: mongoose.Schema<FetchDoc<JSPrimitiveNumberType>, mongoose.Model<FetchDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, FetchDoc<JSPrimitiveNumberType>> & FetchInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, FetchDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<FetchDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<FetchDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const RefreshSchema: mongoose.Schema<RefreshDoc<JSPrimitiveNumberType>, mongoose.Model<RefreshDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, RefreshDoc<JSPrimitiveNumberType>> & RefreshInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, RefreshDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<RefreshDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<RefreshDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const AirdropSchema: mongoose.Schema<AirdropDoc<JSPrimitiveNumberType>, mongoose.Model<AirdropDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, AirdropDoc<JSPrimitiveNumberType>> & AirdropInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, AirdropDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<AirdropDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<AirdropDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const IPFSTotalsSchema: mongoose.Schema<IPFSTotalsDoc<JSPrimitiveNumberType>, mongoose.Model<IPFSTotalsDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, IPFSTotalsDoc<JSPrimitiveNumberType>> & IPFSTotalsInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IPFSTotalsDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<IPFSTotalsDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<IPFSTotalsDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const ComplianceSchema: mongoose.Schema<ComplianceDoc<JSPrimitiveNumberType>, mongoose.Model<ComplianceDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, ComplianceDoc<JSPrimitiveNumberType>> & ComplianceInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ComplianceDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<ComplianceDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<ComplianceDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const BlockinAuthSignatureSchema: mongoose.Schema<BlockinAuthSignatureDoc<JSPrimitiveNumberType>, mongoose.Model<BlockinAuthSignatureDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, BlockinAuthSignatureDoc<JSPrimitiveNumberType>> & BlockinAuthSignatureInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, BlockinAuthSignatureDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<BlockinAuthSignatureDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<BlockinAuthSignatureDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
-export declare const FollowDetailsSchema: mongoose.Schema<FollowDetailsDoc<JSPrimitiveNumberType>, mongoose.Model<FollowDetailsDoc<JSPrimitiveNumberType>, any, any, any, mongoose.Document<unknown, any, FollowDetailsDoc<JSPrimitiveNumberType>> & FollowDetailsInfoBase<JSPrimitiveNumberType> & Doc & Required<{
-    _id: string;
-}>, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, FollowDetailsDoc<JSPrimitiveNumberType>, mongoose.Document<unknown, {}, mongoose.FlatRecord<FollowDetailsDoc<JSPrimitiveNumberType>>> & mongoose.FlatRecord<FollowDetailsDoc<JSPrimitiveNumberType>> & Required<{
-    _id: string;
-}>>;
 //# sourceMappingURL=db.d.ts.map