bitbadgesjs-sdk 0.3.1 → 0.3.3

package/dist/combined.d.ts

@@ -1 +1,1833 @@
+import { DeliverTxResponse } from '@cosmjs/stargate';
+import MerkleTree from 'merkletreejs';
+import { Options as MerkleTreeJsOptions } from 'merkletreejs/dist/MerkleTree';
+export type SupportedChain = 'Bitcoin' | 'Ethereum' | 'Cosmos' | 'Solana' | 'Unknown';
+export interface AssetDetails {
+    chain: string;
+    collectionId: string | number;
+    assetIds: (string | iUintRange)[];
+    ownershipTimes: iUintRange[];
+    mustOwnAmounts: iUintRange;
+    additionalCriteria?: string;
+}
+export interface AndGroup {
+    $and: AssetConditionGroup[];
+}
+export interface OrGroup {
+    $or: AssetConditionGroup[];
+}
+export type AssetConditionGroup = AndGroup | OrGroup | OwnershipRequirements;
+export interface OwnershipRequirements {
+    assets: AssetDetails[];
+    options?: {
+        numMatchesForVerification?: string | number;
+    };
+}
+export interface ChallengeParams {
+    domain: string;
+    statement: string;
+    address: NativeAddress;
+    uri: string;
+    nonce: string;
+    version?: string;
+    chainId?: string;
+    issuedAt?: string;
+    expirationDate?: string;
+    notBefore?: string;
+    resources?: string[];
+    assetOwnershipRequirements?: AssetConditionGroup;
+}
+export interface VerifyChallengeOptions {
+    expectedChallengeParams?: Partial<ChallengeParams>;
+    balancesSnapshot?: object;
+    skipTimestampVerification?: boolean;
+    skipAssetVerification?: boolean;
+    earliestIssuedAt?: string;
+    issuedAtTimeWindowMs?: number;
+    skipSignatureVerification?: boolean;
+}
+export interface Doc {
+    _docId: string;
+    _id?: string;
+}
+export interface ErrorResponse {
+    error?: string;
+    errorMessage: string;
+    unauthorized?: boolean;
+}
+export interface PaginationInfo {
+    bookmark: string;
+    hasMore: boolean;
+}
+export interface iUpdateHistory {
+    txHash: string;
+    block: string | number;
+    blockTimestamp: UNIXMilliTimestamp;
+    timestamp: UNIXMilliTimestamp;
+}
+export interface ErrorDoc {
+    _docId: string;
+    _id?: string;
+    error: string;
+    function: string;
+}
+export type UNIXMilliTimestamp = string | number;
+export type CosmosAddress = string;
+export type BlockinMessage = string;
+export type NativeAddress = string;
+export interface iSocialConnections {
+    discord?: {
+        username: string;
+        id: string;
+        discriminator?: string;
+        lastUpdated: UNIXMilliTimestamp;
+    };
+    twitter?: {
+        username: string;
+        id: string;
+        lastUpdated: UNIXMilliTimestamp;
+    };
+    google?: {
+        username: string;
+        id: string;
+        lastUpdated: UNIXMilliTimestamp;
+    };
+    github?: {
+        username: string;
+        id: string;
+        lastUpdated: UNIXMilliTimestamp;
+    };
+}
+export interface iNotificationPreferences {
+    email?: string;
+    emailVerification?: iEmailVerificationStatus;
+    preferences?: {
+        listActivity?: boolean;
+        transferActivity?: boolean;
+        claimAlerts?: boolean;
+    };
+}
+export interface iEmailVerificationStatus {
+    verified?: boolean;
+    token?: string;
+    expiry?: UNIXMilliTimestamp;
+    antiPhishingCode?: string;
+}
+export interface iActivityDoc extends Doc {
+    timestamp: UNIXMilliTimestamp;
+    block: string | number;
+    _notificationsHandled?: boolean;
+}
+export interface iReviewDoc extends iActivityDoc {
+    review: string;
+    stars: string | number;
+    from: CosmosAddress;
+    collectionId?: string | number;
+    reviewedAddress?: CosmosAddress;
+}
+export interface iTransferActivityDoc extends iActivityDoc {
+    to: CosmosAddress[];
+    from: CosmosAddress;
+    balances: iBalance[];
+    collectionId: string | number;
+    memo?: string;
+    precalculateBalancesFromApproval?: iApprovalIdentifierDetails;
+    prioritizedApprovals?: iApprovalIdentifierDetails[];
+    onlyCheckPrioritizedApprovals?: boolean;
+    initiatedBy: CosmosAddress;
+    txHash?: string;
+}
+export interface iListActivityDoc extends iActivityDoc {
+    listId: string;
+    addedToList?: boolean;
+    addresses?: CosmosAddress[];
+    txHash?: string;
+}
+export interface iClaimAlertDoc extends iActivityDoc {
+    from: string;
+    cosmosAddresses: CosmosAddress[];
+    collectionId: string | number;
+    message?: string;
+}
+export interface iCollectionDoc extends Doc {
+    collectionId: string | number;
+    collectionMetadataTimeline: iCollectionMetadataTimeline[];
+    badgeMetadataTimeline: iBadgeMetadataTimeline[];
+    balancesType: 'Standard' | 'Off-Chain - Indexed' | 'Non-Public' | 'Off-Chain - Non-Indexed';
+    offChainBalancesMetadataTimeline: iOffChainBalancesMetadataTimeline[];
+    customDataTimeline: iCustomDataTimeline[];
+    managerTimeline: iManagerTimeline[];
+    collectionApprovals: iCollectionApproval[];
+    standardsTimeline: iStandardsTimeline[];
+    isArchivedTimeline: iIsArchivedTimeline[];
+    createdBy: CosmosAddress;
+    createdBlock: string | number;
+    createdTimestamp: UNIXMilliTimestamp;
+    updateHistory: iUpdateHistory[];
+    aliasAddress: CosmosAddress;
+}
+export interface iAccountDoc extends Doc {
+    publicKey: string;
+    accountNumber: string | number;
+    pubKeyType: string;
+    cosmosAddress: CosmosAddress;
+    ethAddress: string;
+    solAddress: string;
+    btcAddress: string;
+    sequence?: string | number;
+    balance?: iCosmosCoin;
+}
+export interface iCustomLink {
+    title: string;
+    url: string;
+    image: string;
+}
+export interface iCustomPage {
+    title: string;
+    description: string;
+    items: iBatchBadgeDetails[];
+}
+export interface iCustomListPage {
+    title: string;
+    description: string;
+    items: string[];
+}
+export interface iProfileDoc extends Doc {
+    fetchedProfile?: boolean;
+    seenActivity?: UNIXMilliTimestamp;
+    createdAt?: UNIXMilliTimestamp;
+    discord?: string;
+    twitter?: string;
+    github?: string;
+    telegram?: string;
+    readme?: string;
+    customLinks?: iCustomLink[];
+    hiddenBadges?: iBatchBadgeDetails[];
+    hiddenLists?: string[];
+    customPages?: {
+        badges: iCustomPage[];
+        lists: iCustomListPage[];
+    };
+    watchlists?: {
+        badges: iCustomPage[];
+        lists: iCustomListPage[];
+    };
+    profilePicUrl?: string;
+    username?: string;
+    latestSignedInChain?: SupportedChain;
+    solAddress?: string;
+    notifications?: iNotificationPreferences;
+    socialConnections?: iSocialConnections;
+    approvedSignInMethods?: {
+        discord?: {
+            username: string;
+            discriminator?: string;
+            id: string;
+        };
+    };
+}
+export interface iQueueDoc extends Doc {
+    uri: string;
+    collectionId: string | number;
+    loadBalanceId: string | number;
+    refreshRequestTime: UNIXMilliTimestamp;
+    numRetries: string | number;
+    lastFetchedAt?: UNIXMilliTimestamp;
+    error?: string;
+    deletedAt?: UNIXMilliTimestamp;
+    nextFetchTime?: UNIXMilliTimestamp;
+    emailMessage?: string;
+    recipientAddress?: string;
+    activityDocId?: string;
+    notificationType?: string;
+}
+export interface iIndexerStatus {
+    status: iStatusDoc;
+}
+export interface iLatestBlockStatus {
+    height: string | number;
+    txIndex: string | number;
+    timestamp: UNIXMilliTimestamp;
+}
+export interface iStatusDoc extends Doc {
+    block: iLatestBlockStatus;
+    nextCollectionId: string | number;
+    gasPrice: number;
+    lastXGasAmounts: (string | number)[];
+    lastXGasLimits: (string | number)[];
+}
+export interface iAddressListEditKey {
+    key: string;
+    expirationDate: UNIXMilliTimestamp;
+    mustSignIn?: boolean;
+}
+export interface iAddressListDoc extends iAddressList, Doc {
+    updateHistory: iUpdateHistory[];
+    createdBlock: string | number;
+    lastUpdated: UNIXMilliTimestamp;
+    nsfw?: {
+        reason: string;
+    };
+    reported?: {
+        reason: string;
+    };
+    private?: boolean;
+    viewableWithLink?: boolean;
+}
+export interface iBalanceDoc extends iUserBalanceStore, Doc {
+    collectionId: string | number;
+    cosmosAddress: CosmosAddress;
+    onChain: boolean;
+    uri?: string;
+    fetchedAt?: UNIXMilliTimestamp;
+    fetchedAtBlock?: string | number;
+    isPermanent?: boolean;
+    contentHash?: string;
+    updateHistory: iUpdateHistory[];
+}
+export type ClaimIntegrationPluginType = 'password' | 'numUses' | 'discord' | 'codes' | 'github' | 'google' | 'twitter' | 'transferTimes' | 'requiresProofOfAddress' | 'whitelist' | 'mustOwnBadges' | 'api' | 'email';
+export interface iClaimBuilderDoc extends Doc {
+    cid: string;
+    createdBy: CosmosAddress;
+    docClaimed: boolean;
+    collectionId: string | number;
+    plugins: any[];
+    manualDistribution?: boolean;
+    state: {
+        [pluginId: string]: any;
+    };
+    action: {
+        codes?: string[];
+        seedCode?: string;
+        balancesToSet?: iIncrementedBalances;
+        listId?: string;
+    };
+}
+export interface iApprovalTrackerDoc extends iAmountTrackerIdDetails, Doc {
+    numTransfers: string | number;
+    amounts: iBalance[];
+}
+export interface iChallengeTrackerIdDetails {
+    collectionId: string | number;
+    approvalId: string;
+    challengeTrackerId: string;
+    approvalLevel: 'collection' | 'incoming' | 'outgoing' | '';
+    approverAddress: CosmosAddress;
+}
+export interface iMerkleChallengeDoc extends Doc {
+    collectionId: string | number;
+    challengeTrackerId: string;
+    approvalId: string;
+    approvalLevel: 'collection' | 'incoming' | 'outgoing' | '';
+    approverAddress: CosmosAddress;
+    usedLeafIndices: (string | number)[];
+}
+export interface iMerklechallengeTrackerIdDetails {
+    collectionId: string | number;
+    challengeTrackerId: string;
+    approvalLevel: 'collection' | 'incoming' | 'outgoing' | '';
+    approverAddress: CosmosAddress;
+    usedLeafIndices: (string | number)[];
+}
+export interface iFetchDoc extends Doc {
+    content?: iMetadata | iApprovalInfoDetails | iOffChainBalancesMap | iChallengeDetails;
+    fetchedAt: UNIXMilliTimestamp;
+    fetchedAtBlock: string | number;
+    db: 'ApprovalInfo' | 'Metadata' | 'Balances' | 'ChallengeInfo';
+    isPermanent: boolean;
+}
+export interface iRefreshDoc extends Doc {
+    collectionId: string | number;
+    refreshRequestTime: UNIXMilliTimestamp;
+}
+export interface iAirdropDoc extends Doc {
+    airdropped: boolean;
+    timestamp: UNIXMilliTimestamp;
+    hash?: string;
+}
+export interface iIPFSTotalsDoc extends Doc {
+    bytesUploaded: string | number;
+}
+export interface iComplianceDoc extends Doc {
+    badges: {
+        nsfw: iBatchBadgeDetails[];
+        reported: iBatchBadgeDetails[];
+    };
+    addressLists: {
+        nsfw: {
+            listId: string;
+            reason: string;
+        }[];
+        reported: {
+            listId: string;
+            reason: string;
+        }[];
+    };
+    accounts: {
+        nsfw: {
+            cosmosAddress: CosmosAddress;
+            reason: string;
+        }[];
+        reported: {
+            cosmosAddress: CosmosAddress;
+            reason: string;
+        }[];
+    };
+}
+export interface iBlockinAuthSignatureDoc extends Doc {
+    signature: string;
+    publicKey?: string;
+    name: string;
+    description: string;
+    image: string;
+    cosmosAddress: CosmosAddress;
+    params: ChallengeParams;
+    secretsProofs: iSecretsProof[];
+    createdAt: UNIXMilliTimestamp;
+    deletedAt?: UNIXMilliTimestamp;
+}
+export interface iSecretDoc extends Doc, iSecret {
+    updateHistory: iUpdateHistory[];
+}
+export interface iFollowDetailsDoc extends Doc {
+    cosmosAddress: CosmosAddress;
+    followingCount: string | number;
+    followersCount: string | number;
+    followers: CosmosAddress[];
+    following: CosmosAddress[];
+    followingCollectionId: string | number;
+}
+export interface iMapDoc extends Doc, iMapWithValues {
+}
+export interface iBadgeMetadataDetails {
+    metadataId?: string | number;
+    badgeIds: iUintRange[];
+    metadata: iMetadata;
+    uri?: string;
+    customData?: string;
+    toUpdate?: boolean;
+}
+export interface iMetadata {
+    name: string;
+    description: string;
+    image: string;
+    video?: string;
+    category?: string;
+    externalUrl?: string;
+    tags?: string[];
+    socials?: {
+        [key: string]: string;
+    };
+    offChainTransferabilityInfo?: {
+        host: string;
+        assignMethod: string;
+    };
+    attributes?: {
+        type?: 'date' | 'url';
+        name: string;
+        value: string | number | boolean;
+    }[];
+    fetchedAtBlock?: string | number;
+    fetchedAt?: UNIXMilliTimestamp;
+    _isUpdating?: boolean;
+}
+export interface iBitBadgesAddressList extends iAddressListDoc {
+    metadata?: iMetadata;
+    listsActivity: iListActivityDoc[];
+    views: {
+        [viewId: string]: {
+            ids: string[];
+            type: string;
+            pagination: PaginationInfo;
+        };
+    };
+    claims: {
+        claimId: string;
+        plugins: any[];
+    }[];
+}
+export interface GetAddressListsRouteRequestBody {
+    listsToFetch: {
+        listId: string;
+        viewsToFetch?: {
+            viewId: string;
+            viewType: 'listActivity';
+            bookmark: string;
+        }[];
+        fetchPrivateParams?: boolean;
+    }[];
+}
+export interface iGetAddressListsRouteSuccessResponse {
+    addressLists: iBitBadgesAddressList[];
+}
+export interface UpdateAddressListsRouteRequestBody {
+    addressLists: (iAddressList & {
+        private?: boolean;
+        viewableWithLink?: boolean;
+        claims: {
+            claimId: string;
+            plugins: any[];
+        }[];
+    })[];
+}
+export interface iUpdateAddressListsRouteSuccessResponse {
+}
+export interface CreateAddressListsRouteRequestBody extends UpdateAddressListsRouteRequestBody {
+}
+export interface iCreateAddressListsRouteSuccessResponse {
+}
+export interface DeleteAddressListsRouteRequestBody {
+    listIds: string[];
+}
+export interface iDeleteAddressListsRouteSuccessResponse {
+}
+export interface iBitBadgesUserInfo extends Doc {
+    publicKey: string;
+    accountNumber: string | number;
+    pubKeyType: string;
+    cosmosAddress: CosmosAddress;
+    ethAddress: string;
+    btcAddress: string;
+    sequence?: string | number;
+    balance?: iCosmosCoin;
+    fetchedProfile?: boolean;
+    seenActivity?: UNIXMilliTimestamp;
+    createdAt?: UNIXMilliTimestamp;
+    discord?: string;
+    twitter?: string;
+    github?: string;
+    telegram?: string;
+    readme?: string;
+    customLinks?: iCustomLink[];
+    hiddenBadges?: iBatchBadgeDetails[];
+    hiddenLists?: string[];
+    customPages?: {
+        badges: iCustomPage[];
+        lists: iCustomListPage[];
+    };
+    watchlists?: {
+        badges: iCustomPage[];
+        lists: iCustomListPage[];
+    };
+    profilePicUrl?: string;
+    username?: string;
+    latestSignedInChain?: SupportedChain;
+    notifications?: iNotificationPreferences;
+    socialConnections?: iSocialConnections;
+    approvedSignInMethods?: {
+        discord?: {
+            username: string;
+            discriminator?: string;
+            id: string;
+        };
+    };
+    resolvedName?: string;
+    avatar?: string;
+    solAddress: string;
+    chain: SupportedChain;
+    airdropped?: boolean;
+    collected: iBalanceDoc[];
+    activity: iTransferActivityDoc[];
+    listsActivity: iListActivityDoc[];
+    reviews: iReviewDoc[];
+    merkleChallenges: iMerkleChallengeDoc[];
+    approvalTrackers: iApprovalTrackerDoc[];
+    addressLists: iBitBadgesAddressList[];
+    claimAlerts: iClaimAlertDoc[];
+    authCodes: iBlockinAuthSignatureDoc[];
+    secrets: iSecretDoc[];
+    reservedMap?: iMapDoc;
+    address: NativeAddress;
+    nsfw?: {
+        [badgeId: string]: string;
+    };
+    reported?: {
+        [badgeId: string]: string;
+    };
+    views: {
+        [viewId: string]: {
+            ids: string[];
+            type: string;
+            pagination: PaginationInfo;
+        } | undefined;
+    };
+    alias?: {
+        collectionId?: string | number;
+        listId?: string;
+    };
+}
+export type AccountViewKey = 'createdLists' | 'privateLists' | 'authCodes' | 'transferActivity' | 'reviews' | 'badgesCollected' | 'claimAlerts' | 'sentClaimAlerts' | 'allLists' | 'whitelists' | 'blacklists' | 'createdBadges' | 'managingBadges' | 'listsActivity' | 'createdSecrets' | 'receivedSecrets';
+export type AccountFetchDetails = {
+    address?: string;
+    username?: string;
+    fetchSequence?: boolean;
+    fetchBalance?: boolean;
+    noExternalCalls?: boolean;
+    viewsToFetch?: {
+        viewId: string;
+        viewType: AccountViewKey;
+        specificCollections?: iBatchBadgeDetails[];
+        specificLists?: string[];
+        oldestFirst?: boolean;
+        bookmark: string;
+    }[];
+};
+export interface GetAccountsRouteRequestBody {
+    accountsToFetch: AccountFetchDetails[];
+}
+export interface iGetAccountsRouteSuccessResponse {
+    accounts: iBitBadgesUserInfo[];
+}
+export interface GetFollowDetailsRouteRequestBody {
+    cosmosAddress: string;
+    followingBookmark?: string;
+    followersBookmark?: string;
+    protocol?: string;
+    activityBookmark?: string;
+}
+export interface iGetFollowDetailsRouteSuccessResponse extends iFollowDetailsDoc {
+    followersPagination: PaginationInfo;
+    followingPagination: PaginationInfo;
+    activity: iTransferActivityDoc[];
+    activityPagination: PaginationInfo;
+}
+export interface FilterBadgesInCollectionRequestBody {
+    collectionId: string | number;
+    badgeIds?: iUintRange[];
+    categories?: string[];
+    tags?: string[];
+    mostViewed?: 'daily' | 'allTime' | 'weekly' | 'monthly' | 'yearly';
+    bookmark?: string;
+    attributes?: {
+        name: string;
+        value: string | number | boolean;
+    }[];
+}
+export interface iFilterBadgesInCollectionSuccessResponse {
+    badgeIds: iUintRange[];
+    pagination: PaginationInfo;
+}
+export interface GetOwnersForBadgeRouteRequestBody {
+    bookmark?: string;
+}
+export interface iGetOwnersForBadgeRouteSuccessResponse {
+    owners: iBalanceDoc[];
+    pagination: PaginationInfo;
+}
+export interface GetBadgeBalanceByAddressRouteRequestBody {
+}
+export interface iGetBadgeBalanceByAddressRouteSuccessResponse extends iBalanceDoc {
+}
+export interface GetBadgeActivityRouteRequestBody {
+    bookmark?: string;
+}
+export interface iGetBadgeActivityRouteSuccessResponse {
+    activity: iTransferActivityDoc[];
+    pagination: PaginationInfo;
+}
+export interface MetadataFetchOptions {
+    doNotFetchCollectionMetadata?: boolean;
+    metadataIds?: string | number[] | iUintRange[];
+    uris?: string[];
+    badgeIds?: string | number[] | iUintRange[];
+}
+export type CollectionViewKey = 'transferActivity' | 'reviews' | 'owners' | 'amountTrackers' | 'challengeTrackers';
+export interface GetAdditionalCollectionDetailsRequestBody {
+    viewsToFetch?: {
+        viewType: CollectionViewKey;
+        viewId: string;
+        bookmark: string;
+        oldestFirst?: boolean;
+    }[];
+    fetchTotalAndMintBalances?: boolean;
+    challengeTrackersToFetch?: iChallengeTrackerIdDetails[];
+    approvalTrackersToFetch?: iAmountTrackerIdDetails[];
+    handleAllAndAppendDefaults?: boolean;
+    fetchPrivateParams?: boolean;
+}
+export interface GetMetadataForCollectionRequestBody {
+    metadataToFetch?: MetadataFetchOptions;
+}
+export interface GetCollectionsRouteRequestBody {
+    collectionsToFetch: ({
+        collectionId: string | number;
+    } & GetMetadataForCollectionRequestBody & GetAdditionalCollectionDetailsRequestBody)[];
+}
+export interface iGetCollectionsRouteSuccessResponse {
+    collections: iBitBadgesCollection[];
+}
+export interface GetCollectionByIdRouteRequestBody extends GetAdditionalCollectionDetailsRequestBody, GetMetadataForCollectionRequestBody {
+}
+export interface iGetCollectionByIdRouteSuccessResponse {
+    collection: iBitBadgesCollection;
+}
+export interface RefreshMetadataRouteRequestBody {
+}
+export interface iRefreshMetadataRouteSuccessResponse {
+}
+export interface RefreshStatusRouteRequestBody {
+}
+export interface iRefreshStatusRouteSuccessResponse {
+    inQueue: boolean;
+    errorDocs: iQueueDoc[];
+    refreshDoc: iRefreshDoc;
+}
+export interface GetStatusRouteRequestBody {
+}
+export interface iGetStatusRouteSuccessResponse {
+    status: iStatusDoc;
+}
+export interface GetSearchRouteRequestBody {
+    noCollections?: boolean;
+    noAccounts?: boolean;
+    noAddressLists?: boolean;
+    noBadges?: boolean;
+    specificCollectionId?: string | number;
+}
+export interface iGetSearchRouteSuccessResponse {
+    collections: iBitBadgesCollection[];
+    accounts: iBitBadgesUserInfo[];
+    addressLists: iBitBadgesAddressList[];
+    badges: {
+        collection: iBitBadgesCollection;
+        badgeIds: iUintRange[];
+    }[];
+}
+export interface GetClaimsRouteRequestBody {
+    claimIds: string[];
+    listId?: string;
+}
+export interface iClaimDetails {
+    claimId: string;
+    balancesToSet?: iIncrementedBalances;
+    plugins: any[];
+    manualDistribution?: boolean;
+}
+export interface iGetClaimsRouteSuccessResponse {
+    claims: iClaimDetails[];
+}
+export interface CheckAndCompleteClaimRouteRequestBody {
+    [pluginId: string]: any;
+    prevCodesOnly?: boolean;
+}
+export interface iCheckAndCompleteClaimRouteSuccessResponse {
+    code?: string;
+    prevCodes?: string[];
+}
+export interface DeleteReviewRouteRequestBody {
+    reviewId: string;
+}
+export interface iDeleteReviewRouteSuccessResponse {
+}
+export interface AddReviewForCollectionRouteRequestBody {
+    review: string;
+    stars: string | number;
+    cosmosAddress: CosmosAddress;
+    collectionId: string | number;
+}
+export interface iAddReviewForCollectionRouteSuccessResponse {
+}
+export interface AddReviewForUserRouteRequestBody {
+    review: string;
+    stars: string | number;
+}
+export interface iAddReviewForUserRouteSuccessResponse {
+}
+export interface UpdateAccountInfoRouteRequestBody {
+    discord?: string;
+    twitter?: string;
+    github?: string;
+    telegram?: string;
+    seenActivity?: UNIXMilliTimestamp;
+    readme?: string;
+    hiddenBadges?: iBatchBadgeDetails[];
+    hiddenLists?: string[];
+    customPages?: {
+        badges: iCustomPage[];
+        lists: iCustomListPage[];
+    };
+    watchlists?: {
+        badges: iCustomPage[];
+        lists: iCustomListPage[];
+    };
+    profilePicUrl?: string;
+    username?: string;
+    profilePicImageFile?: any;
+    notifications?: {
+        email?: string;
+        antiPhishingCode?: string;
+        preferences?: {};
+    };
+    approvedSignInMethods?: {
+        discord?: {
+            username: string;
+            discriminator?: string;
+            id: string;
+        };
+    };
+    socialConntections?: iSocialConnections;
+}
+export interface iUpdateAccountInfoRouteSuccessResponse {
+}
+export interface AddBalancesToOffChainStorageRouteRequestBody {
+    balances?: iOffChainBalancesMap;
+    claims?: {
+        claimId: string;
+        plugins: any[];
+        balancesToSet?: iIncrementedBalances;
+    }[];
+    method: 'ipfs' | 'centralized';
+    collectionId: string | number;
+}
+export interface iAddBalancesToOffChainStorageRouteSuccessResponse {
+    uri?: string;
+    result: {
+        cid?: string;
+    };
+}
+export interface AddMetadataToIpfsRouteRequestBody {
+    collectionMetadata?: iMetadata;
+    badgeMetadata?: iBadgeMetadataDetails[] | iMetadata[];
+}
+export interface iAddMetadataToIpfsRouteSuccessResponse {
+    collectionMetadataResult?: {
+        cid: string;
+    };
+    badgeMetadataResults: {
+        cid: string;
+    }[];
+}
+export interface AddApprovalDetailsToOffChainStorageRouteRequestBody {
+    name: string;
+    description: string;
+    challengeDetails?: iChallengeDetails;
+    claims?: {
+        plugins: any[];
+        claimId: string;
+        manualDistribution?: boolean;
+    }[];
+}
+export interface iAddApprovalDetailsToOffChainStorageRouteSuccessResponse {
+    result: {
+        cid: string;
+    };
+    challengeResult?: {
+        cid: string;
+    };
+}
+export interface GetSignInChallengeRouteRequestBody {
+    chain: SupportedChain;
+    address: NativeAddress;
+    hours?: string | number;
+}
+export interface iGetSignInChallengeRouteSuccessResponse {
+    nonce: string;
+    params: ChallengeParams;
+    message: BlockinMessage;
+}
+export interface VerifySignInRouteRequestBody {
+    message: BlockinMessage;
+    signature: string;
+    publicKey?: string;
+}
+export interface iVerifySignInRouteSuccessResponse {
+}
+export interface CheckSignInStatusRequestBody {
+}
+export interface iCheckSignInStatusRequestSuccessResponse {
+    signedIn: boolean;
+    message: BlockinMessage;
+    discord?: {
+        username: string;
+        discriminator: string;
+        id: string;
+    };
+    twitter?: {
+        id: string;
+        username: string;
+    };
+    github?: {
+        id: string;
+        username: string;
+    };
+    google?: {
+        id: string;
+        username: string;
+    };
+}
+export interface SignOutRequestBody {
+    signOutBlockin: boolean;
+    signOutDiscord?: boolean;
+    signOutTwitter?: boolean;
+    signOutGoogle?: boolean;
+    signOutGithub?: boolean;
+}
+export interface iSignOutSuccessResponse {
+}
+export interface GetBrowseCollectionsRouteRequestBody {
+}
+export interface iGetBrowseCollectionsRouteSuccessResponse {
+    collections: {
+        [category: string]: iBitBadgesCollection[];
+    };
+    addressLists: {
+        [category: string]: iBitBadgesAddressList[];
+    };
+    profiles: {
+        [category: string]: iBitBadgesUserInfo[];
+    };
+    activity: iTransferActivityDoc[];
+    badges: {
+        [category: string]: {
+            collection: iBitBadgesCollection;
+            badgeIds: iUintRange[];
+        }[];
+    };
+}
+export type BroadcastTxRouteRequestBody = BroadcastPostBody;
+export interface iBroadcastTxRouteSuccessResponse {
+    tx_response: {
+        code: number;
+        codespace: string;
+        data: string;
+        events: {
+            type: string;
+            attributes: {
+                key: string;
+                value: string;
+                index: boolean;
+            }[];
+        }[];
+        gas_wanted: string;
+        gas_used: string;
+        height: string;
+        Doc: string;
+        logs: {
+            events: {
+                type: string;
+                attributes: {
+                    key: string;
+                    value: string;
+                    index: boolean;
+                }[];
+            }[];
+        }[];
+        raw_log: string;
+        timestamp: string;
+        tx: object | null;
+        txhash: string;
+    };
+}
+export type SimulateTxRouteRequestBody = BroadcastPostBody;
+export interface iSimulateTxRouteSuccessResponse {
+    gas_info: {
+        gas_used: string;
+        gas_wanted: string;
+    };
+    result: {
+        data: string;
+        log: string;
+        events: {
+            type: string;
+            attributes: {
+                key: string;
+                value: string;
+                index: boolean;
+            }[];
+        }[];
+    };
+}
+export interface FetchMetadataDirectlyRouteRequestBody {
+    uris: string[];
+}
+export interface iFetchMetadataDirectlyRouteSuccessResponse {
+    metadata: iMetadata[];
+}
+export interface GetTokensFromFaucetRouteRequestBody {
+}
+export type iGetTokensFromFaucetRouteSuccessResponse = DeliverTxResponse;
+export interface SendClaimAlertsRouteRequestBody {
+    claimAlerts: {
+        collectionId: string | number;
+        message?: string;
+        cosmosAddresses: CosmosAddress[];
+    }[];
+}
+export interface iSendClaimAlertsRouteSuccessResponse {
+}
+export interface CosmosAccountResponse {
+    account_number: number;
+    sequence: number;
+    pub_key: {
+        key: string;
+    };
+    address: CosmosAddress;
+}
+export interface GenericBlockinVerifyRouteRequestBody extends VerifySignInRouteRequestBody {
+    options?: VerifyChallengeOptions;
+}
+export interface iGenericBlockinVerifyRouteSuccessResponse extends iVerifySignInRouteSuccessResponse {
+}
+export interface CreateSecretRouteRequestBody {
+    proofOfIssuance: {
+        message: string;
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    messageFormat: 'plaintext' | 'json';
+    scheme: 'bbs' | 'standard';
+    type: string;
+    secretMessages: string[];
+    dataIntegrityProof: {
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    name: string;
+    image: string;
+    description: string;
+}
+export interface iCreateSecretRouteSuccessResponse {
+    secretId: string;
+}
+export interface GetSecretRouteRequestBody {
+    secretId: string;
+}
+export interface iGetSecretRouteSuccessResponse extends iSecretDoc {
+}
+export interface DeleteSecretRouteRequestBody {
+    secretId: string;
+}
+export interface iDeleteSecretRouteSuccessResponse {
+}
+export interface UpdateSecretRouteRequestBody {
+    secretId: string;
+    holdersToSet?: {
+        cosmosAddress: CosmosAddress;
+        delete?: boolean;
+    }[];
+    anchorsToAdd?: {
+        txHash?: string;
+        message?: string;
+    }[];
+    proofOfIssuance?: {
+        message: string;
+        signer: string;
+        signature: string;
+        publicKey?: string;
+    };
+    messageFormat?: 'plaintext' | 'json';
+    scheme?: 'bbs' | 'standard';
+    type?: string;
+    secretMessages?: string[];
+    dataIntegrityProof?: {
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    name?: string;
+    image?: string;
+    description?: string;
+}
+export interface iUpdateSecretRouteSuccessResponse {
+}
+export interface CreateBlockinAuthCodeRouteRequestBody {
+    name: string;
+    description: string;
+    image: string;
+    message: BlockinMessage;
+    signature: string;
+    publicKey?: string;
+    secretsProofs?: iSecretsProof[];
+}
+export interface iCreateBlockinAuthCodeRouteSuccessResponse {
+    id: string;
+}
+export interface GetBlockinAuthCodeRouteRequestBody {
+    id: string;
+    options?: VerifyChallengeOptions;
+}
+export interface iGetBlockinAuthCodeRouteSuccessResponse {
+    message: BlockinMessage;
+    signature: string;
+    params: ChallengeParams;
+    cosmosAddress: CosmosAddress;
+    verificationResponse: {
+        success: boolean;
+        errorMessage?: string;
+    };
+    secretsProofs: iSecretsProof[];
+}
+export interface DeleteBlockinAuthCodeRouteRequestBody {
+    id: string;
+}
+export interface iDeleteBlockinAuthCodeRouteSuccessResponse {
+}
+export interface GenerateAppleWalletPassRouteRequestBody {
+    name: string;
+    description: string;
+    message: BlockinMessage;
+    signature: string;
+}
+export interface iGenerateAppleWalletPassRouteSuccessResponse {
+    type: string;
+    data: string;
+}
+export interface GetClaimAlertsForCollectionRouteRequestBody {
+    collectionId: string | number;
+    bookmark: string;
+}
+export interface iGetClaimAlertsForCollectionRouteSuccessResponse {
+    claimAlerts: iClaimAlertDoc[];
+    pagination: PaginationInfo;
+}
+export interface GetExternalCallRouteRequestBody {
+    uri: string;
+    key: string;
+}
+export interface iGetExternalCallRouteSuccessResponse {
+    key: string;
+    timestamp: number;
+}
+export interface GetMapsRouteRequestBody {
+    mapIds: string[];
+}
+export interface iMapWithValues extends iMap {
+    values: {
+        [key: string]: iValueStore;
+    };
+    metadata?: iMetadata;
+    updateHistory: iUpdateHistory[];
+}
+export interface iGetMapsRouteSuccessResponse {
+    maps: iMapWithValues[];
+}
+export interface iBitBadgesCollection extends iCollectionDoc {
+    collectionApprovals: iCollectionApproval[];
+    collectionPermissions: iCollectionPermissions;
+    cachedCollectionMetadata?: iMetadata;
+    cachedBadgeMetadata: iBadgeMetadataDetails[];
+    defaultBalances: iUserBalanceStore;
+    activity: iTransferActivityDoc[];
+    reviews: iReviewDoc[];
+    owners: iBalanceDoc[];
+    merkleChallenges: iMerkleChallengeDoc[];
+    approvalTrackers: iApprovalTrackerDoc[];
+    nsfw?: {
+        badgeIds: iUintRange[];
+        reason: string;
+    };
+    reported?: {
+        badgeIds: iUintRange[];
+        reason: string;
+    };
+    reservedMap?: iMapDoc;
+    views: {
+        [viewId: string]: {
+            ids: string[];
+            type: string;
+            pagination: PaginationInfo;
+        } | undefined;
+    };
+    claims: iClaimDetails[];
+}
+export interface iOffChainBalancesMap {
+    [cosmosAddressOrListId: string]: iBalance[];
+}
+export interface iTransferWithIncrements extends iTransfer {
+    toAddressesLength?: string | number;
+    incrementBadgeIdsBy?: string | number;
+    incrementOwnershipTimesBy?: string | number;
+}
+export interface iBatchBadgeDetails {
+    collectionId: string | number;
+    badgeIds: iUintRange[];
+}
+export interface iChallengeDetails {
+    leaves: string[];
+    isHashed: boolean;
+    preimages?: string[];
+    seedCode?: string;
+    tree?: MerkleTree;
+    treeOptions?: MerkleTreeJsOptions;
+    numLeaves?: string | number;
+    currCode?: string | number;
+}
+export interface iChallengeInfoDetails {
+    challengeDetails: iChallengeDetails;
+    claim?: iClaimDetails;
+}
+export interface iApprovalInfoDetails {
+    name: string;
+    description: string;
+}
+export interface iCosmosCoin {
+    amount: string | number;
+    denom: string;
+}
+export type PermissionNameString = 'canDeleteCollection' | 'canArchiveCollection' | 'canUpdateOffChainBalancesMetadata' | 'canUpdateBadgeMetadata' | 'canUpdateCollectionMetadata' | 'canCreateMoreBadges' | 'canUpdateCollectionApprovals' | 'canUpdateAutoApproveSelfInitiatedIncomingTransfers' | 'canUpdateAutoApproveSelfInitiatedOutgoingTransfers' | 'canUpdateStandards' | 'canUpdateCustomData' | 'canUpdateManager';
+export interface Validator {
+    commission: {
+        commission_rates: {
+            max_change_rate: string;
+            max_rate: string;
+            rate: string;
+        };
+        update_time: string;
+    };
+    consensus_pubkey: {
+        '@type': string;
+        key: string;
+    };
+    delegator_shares: string;
+    description: {
+        details: string;
+        identity: string;
+        moniker: string;
+        security_contact: string;
+        website: string;
+    };
+    jailed: boolean;
+    min_self_delegation: string;
+    operator_address: string;
+    status: string;
+    tokens: string;
+    unbonding_height: string;
+    unbonding_time: string;
+}
+export interface GetValidatorsResponse {
+    validators: Validator[];
+    pagination: {
+        next_key: string;
+        total: number;
+    };
+}
+export interface UndelegationResponse {
+    delegator_address: string;
+    validator_address: string;
+    entries: [
+        {
+            creation_height: string;
+            completion_time: string;
+            initial_balance: string;
+            balance: string;
+        }
+    ];
+}
+export interface GetUndelegationsResponse {
+    unbonding_responses: UndelegationResponse[];
+    pagination: {
+        next_key: string;
+        total: string;
+    };
+}
+export interface CounterParty {
+    port_id: string;
+    channel_id: string;
+}
+export interface Channel {
+    state: string;
+    ordering: string;
+    counterparty: CounterParty;
+    connection_hops: string[];
+    version: string;
+    port_id: string;
+    channel_id: string;
+}
+export interface ChannelsResponse {
+    channels: Channel[];
+    pagination: {
+        next_key?: string;
+        total: string;
+    };
+    height: {
+        revision_number: string;
+        revision_height: string;
+    };
+}
+export interface TallyResponse {
+    tally: {
+        yes: string;
+        abstain: string;
+        no: string;
+        no_with_veto: string;
+    };
+}
+export interface AccountResponse {
+    account: {
+        '@type': string;
+        base_account: {
+            address: string;
+            pub_key?: {
+                '@type': string;
+                key: string;
+            };
+            account_number: string;
+            sequence: string;
+        };
+    };
+}
+export declare enum BroadcastMode {
+    Unspecified = "BROADCAST_MODE_UNSPECIFIED",
+    Sync = "BROADCAST_MODE_SYNC",
+    Async = "BROADCAST_MODE_ASYNC"
+}
+export interface BroadcastPostBody {
+    tx_bytes: Uint8Array;
+    mode: string;
+}
+export interface TxContext {
+    chain: Chain;
+    sender: Sender;
+    fee: Fee;
+    memo: string;
+}
+export interface EIP712ToSign {
+    types: object;
+    primaryType: string;
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+        salt: string;
+    };
+    message: object;
+}
+export interface Fee {
+    amount: string;
+    denom: string;
+    gas: string;
+}
+export interface Sender {
+    accountAddress: CosmosAddress;
+    sequence: number;
+    accountNumber: number;
+    pubkey: string;
+}
+export interface Chain {
+    chainId: number;
+    cosmosChainId: string;
+    chain: SupportedChain;
+}
+export interface iMsgInstantiateContractCompat {
+    sender: string;
+    codeId: string;
+    label: string;
+    funds: string;
+}
+export interface iMsgStoreCodeCompat {
+    sender: string;
+    hexWasmByteCode: string;
+}
+export interface iMsgExecuteContractCompat {
+    sender: string;
+    contract: string;
+    msg: string;
+    funds: string;
+}
+export interface iValueStore {
+    key: string;
+    value: string;
+    lastSetBy: string;
+}
+export interface iMapUpdateCriteria {
+    managerOnly: boolean;
+    collectionId: string | number;
+    creatorOnly: boolean;
+    firstComeFirstServe: boolean;
+}
+export interface iValueOptions {
+    noDuplicates: boolean;
+    permanentOnceSet: boolean;
+    expectUint: boolean;
+    expectBoolean: boolean;
+    expectAddress: boolean;
+    expectUri: boolean;
+}
+export interface iMapPermissions {
+    canUpdateMetadata: iTimedUpdatePermission[];
+    canUpdateManager: iTimedUpdatePermission[];
+    canDeleteMap: iActionPermission[];
+}
+export interface iMap {
+    creator: CosmosAddress;
+    mapId: string;
+    inheritManagerTimelineFrom: string | number;
+    managerTimeline: iManagerTimeline[];
+    updateCriteria: iMapUpdateCriteria;
+    valueOptions: iValueOptions;
+    defaultValue: string;
+    permissions: iMapPermissions;
+    metadataTimeline: iMapMetadataTimeline[];
+}
+export interface iMapMetadataTimeline {
+    timelineTimes: iUintRange[];
+    metadata: iCollectionMetadata;
+}
+export interface iMsgCreateMap {
+    creator: CosmosAddress;
+    mapId: string;
+    inheritManagerTimelineFrom: string | number;
+    managerTimeline: iManagerTimeline[];
+    updateCriteria: iMapUpdateCriteria;
+    valueOptions: iValueOptions;
+    defaultValue: string;
+    metadataTimeline: iMapMetadataTimeline[];
+    permissions: iMapPermissions;
+}
+export interface iMsgUpdateMap {
+    creator: CosmosAddress;
+    mapId: string;
+    updateManagerTimeline: boolean;
+    managerTimeline: iManagerTimeline[];
+    updateMetadataTimeline: boolean;
+    metadataTimeline: iMapMetadataTimeline[];
+    updatePermissions: boolean;
+    permissions: iMapPermissions;
+}
+export interface iMsgDeleteMap {
+    creator: CosmosAddress;
+    mapId: string;
+}
+export interface iMsgSetValue {
+    creator: CosmosAddress;
+    mapId: string;
+    key: string;
+    value: string;
+    options: iSetOptions;
+}
+export interface iSetOptions {
+    useMostRecentCollectionId: boolean;
+}
+export interface iMsgCreateAddressLists {
+    creator: CosmosAddress;
+    addressLists: iAddressList[];
+}
+export interface iMsgCreateCollection {
+    creator: CosmosAddress;
+    balancesType?: string;
+    defaultBalances?: iUserBalanceStore;
+    badgesToCreate?: iBalance[];
+    collectionPermissions?: iCollectionPermissions;
+    managerTimeline?: iManagerTimeline[];
+    collectionMetadataTimeline?: iCollectionMetadataTimeline[];
+    badgeMetadataTimeline?: iBadgeMetadataTimeline[];
+    offChainBalancesMetadataTimeline?: iOffChainBalancesMetadataTimeline[];
+    customDataTimeline?: iCustomDataTimeline[];
+    collectionApprovals?: iCollectionApproval[];
+    standardsTimeline?: iStandardsTimeline[];
+    isArchivedTimeline?: iIsArchivedTimeline[];
+}
+export interface iMsgDeleteCollection {
+    creator: CosmosAddress;
+    collectionId: string | number;
+}
+export interface iMsgTransferBadges {
+    creator: CosmosAddress;
+    collectionId: string | number;
+    transfers: iTransfer[];
+}
+export interface iMsgUniversalUpdateCollection extends iMsgCreateCollection {
+    collectionId: string | number;
+    updateCollectionPermissions?: boolean;
+    updateManagerTimeline?: boolean;
+    updateCollectionMetadataTimeline?: boolean;
+    updateBadgeMetadataTimeline?: boolean;
+    updateOffChainBalancesMetadataTimeline?: boolean;
+    updateCustomDataTimeline?: boolean;
+    updateCollectionApprovals?: boolean;
+    updateStandardsTimeline?: boolean;
+    updateIsArchivedTimeline?: boolean;
+}
+export interface iMsgUpdateCollection extends Omit<iMsgUniversalUpdateCollection, 'defaultBalances' | 'balancesType'> {
+}
+export interface iMsgUpdateUserApprovals {
+    creator: CosmosAddress;
+    collectionId: string | number;
+    updateOutgoingApprovals?: boolean;
+    outgoingApprovals?: iUserOutgoingApproval[];
+    updateIncomingApprovals?: boolean;
+    incomingApprovals?: iUserIncomingApproval[];
+    updateAutoApproveSelfInitiatedOutgoingTransfers?: boolean;
+    autoApproveSelfInitiatedOutgoingTransfers?: boolean;
+    updateAutoApproveSelfInitiatedIncomingTransfers?: boolean;
+    autoApproveSelfInitiatedIncomingTransfers?: boolean;
+    updateUserPermissions?: boolean;
+    userPermissions?: iUserPermissions;
+}
+export type SupportedChainType = 'Bitcoin' | 'Ethereum' | 'Cosmos' | 'Solana' | 'Unknown';
+export type NumberType = bigint | number | string;
+export type JSPrimitiveNumberType = string | number;
+export interface iUserPermissions {
+    canUpdateOutgoingApprovals: iUserOutgoingApprovalPermission[];
+    canUpdateIncomingApprovals: iUserIncomingApprovalPermission[];
+    canUpdateAutoApproveSelfInitiatedOutgoingTransfers: iActionPermission[];
+    canUpdateAutoApproveSelfInitiatedIncomingTransfers: iActionPermission[];
+}
+export interface iUserOutgoingApprovalPermission {
+    toListId: string;
+    toList: iAddressList;
+    initiatedByListId: string;
+    initiatedByList: iAddressList;
+    transferTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    approvalId: string;
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iUserIncomingApprovalPermission {
+    fromListId: string;
+    fromList: iAddressList;
+    initiatedByListId: string;
+    initiatedByList: iAddressList;
+    transferTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    approvalId: string;
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iCollectionPermissions {
+    canDeleteCollection: iActionPermission[];
+    canArchiveCollection: iTimedUpdatePermission[];
+    canUpdateOffChainBalancesMetadata: iTimedUpdatePermission[];
+    canUpdateStandards: iTimedUpdatePermission[];
+    canUpdateCustomData: iTimedUpdatePermission[];
+    canUpdateManager: iTimedUpdatePermission[];
+    canUpdateCollectionMetadata: iTimedUpdatePermission[];
+    canCreateMoreBadges: iBalancesActionPermission[];
+    canUpdateBadgeMetadata: iTimedUpdateWithBadgeIdsPermission[];
+    canUpdateCollectionApprovals: iCollectionApprovalPermission[];
+}
+export interface iActionPermission {
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iTimedUpdatePermission {
+    timelineTimes: iUintRange[];
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iBalancesActionPermission {
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iTimedUpdateWithBadgeIdsPermission {
+    timelineTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iCollectionApprovalPermission {
+    fromListId: string;
+    fromList: iAddressList;
+    toListId: string;
+    toList: iAddressList;
+    initiatedByListId: string;
+    initiatedByList: iAddressList;
+    transferTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    approvalId: string;
+    permanentlyPermittedTimes: iUintRange[];
+    permanentlyForbiddenTimes: iUintRange[];
+}
+export interface iUintRange {
+    start: string | number;
+    end: string | number;
+}
+export interface iBadgeMetadata {
+    uri: string;
+    badgeIds: iUintRange[];
+    customData: string;
+}
+export interface iCollectionMetadata {
+    uri: string;
+    customData: string;
+}
+export interface iOffChainBalancesMetadata {
+    uri: string;
+    customData: string;
+}
+export interface iSecretsProof {
+    entropies?: string[];
+    updateHistory?: iUpdateHistory[];
+    messageFormat: 'plaintext' | 'json';
+    createdBy: CosmosAddress;
+    proofOfIssuance: {
+        message: string;
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    scheme: 'bbs' | 'standard';
+    secretMessages: string[];
+    dataIntegrityProof: {
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    name: string;
+    image: string;
+    description: string;
+    anchors?: {
+        txHash?: string;
+        message?: string;
+    }[];
+}
+export interface iSecret {
+    messageFormat: 'plaintext' | 'json';
+    createdBy: CosmosAddress;
+    proofOfIssuance: {
+        message: string;
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    secretId: string;
+    scheme: 'bbs' | 'standard';
+    type: string;
+    secretMessages: string[];
+    dataIntegrityProof: {
+        signature: string;
+        signer: string;
+        publicKey?: string;
+    };
+    name: string;
+    image: string;
+    description: string;
+    holders: string[];
+    anchors: {
+        txHash?: string;
+        message?: string;
+    }[];
+}
+export interface iZkProof {
+    verificationKey: string;
+    uri: string;
+    customData: string;
+    zkpTrackerId: string;
+}
+export interface iZkProofSolution {
+    proof: string;
+    publicInputs: string;
+}
+export interface iMustOwnBadges {
+    collectionId: string | number;
+    amountRange: iUintRange;
+    ownershipTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    overrideWithCurrentTime: boolean;
+    mustSatisfyForAllAssets: boolean;
+}
+export interface iBalance {
+    amount: string | number;
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+}
+export interface iAddressList {
+    listId: string;
+    addresses: string[];
+    whitelist: boolean;
+    uri: string;
+    customData: string;
+    createdBy?: CosmosAddress;
+    aliasAddress?: CosmosAddress;
+}
+export interface iTransfer {
+    from: CosmosAddress;
+    toAddresses: CosmosAddress[];
+    balances: iBalance[];
+    precalculateBalancesFromApproval?: iApprovalIdentifierDetails;
+    merkleProofs?: iMerkleProof[];
+    memo?: string;
+    prioritizedApprovals?: iApprovalIdentifierDetails[];
+    onlyCheckPrioritizedApprovals?: boolean;
+    zkProofSolutions?: iZkProofSolution[];
+}
+export interface iApprovalIdentifierDetails {
+    approvalId: string;
+    approvalLevel: string;
+    approverAddress: CosmosAddress;
+}
+export interface iCoinTransfer {
+    to: CosmosAddress;
+    coins: iCosmosCoin[];
+}
+export interface iAmountTrackerIdDetails {
+    collectionId: string | number;
+    approvalId: string;
+    amountTrackerId: string;
+    approvalLevel: string;
+    approverAddress: CosmosAddress;
+    trackerType: string;
+    approvedAddress: CosmosAddress;
+}
+export interface iMerkleChallenge {
+    root: string;
+    expectedProofLength: string | number;
+    useCreatorAddressAsLeaf: boolean;
+    maxUsesPerLeaf: string | number;
+    uri: string;
+    customData: string;
+    challengeTrackerId: string;
+}
+export interface iMerklePathItem {
+    aunt: string;
+    onRight: boolean;
+}
+export interface iMerkleProof {
+    aunts: iMerklePathItem[];
+    leaf: string;
+}
+export interface iTimelineItem {
+    timelineTimes: iUintRange[];
+}
+export interface iManagerTimeline extends iTimelineItem {
+    manager: CosmosAddress;
+}
+export interface iCollectionMetadataTimeline extends iTimelineItem {
+    collectionMetadata: iCollectionMetadata;
+}
+export interface iBadgeMetadataTimeline extends iTimelineItem {
+    badgeMetadata: iBadgeMetadata[];
+}
+export interface iOffChainBalancesMetadataTimeline extends iTimelineItem {
+    offChainBalancesMetadata: iOffChainBalancesMetadata;
+}
+export interface iCustomDataTimeline extends iTimelineItem {
+    customData: string;
+}
+export interface iStandardsTimeline extends iTimelineItem {
+    standards: string[];
+}
+export interface iIsArchivedTimeline extends iTimelineItem {
+    isArchived: boolean;
+}
+export interface iUserOutgoingApproval {
+    toListId: string;
+    toList: iAddressList;
+    initiatedByListId: string;
+    initiatedByList: iAddressList;
+    transferTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    approvalId: string;
+    uri?: string;
+    customData?: string;
+    approvalCriteria?: iOutgoingApprovalCriteria;
+}
+export interface iOutgoingApprovalCriteria {
+    mustOwnBadges?: iMustOwnBadges[];
+    zkProofs?: iZkProof[];
+    coinTransfers?: iCoinTransfer[];
+    merkleChallenges?: iMerkleChallenge[];
+    predeterminedBalances?: iPredeterminedBalances;
+    approvalAmounts?: iApprovalAmounts;
+    maxNumTransfers?: iMaxNumTransfers;
+    requireToEqualsInitiatedBy?: boolean;
+    requireToDoesNotEqualInitiatedBy?: boolean;
+}
+export interface iPredeterminedBalances {
+    manualBalances: iManualBalances[];
+    incrementedBalances: iIncrementedBalances;
+    orderCalculationMethod: iPredeterminedOrderCalculationMethod;
+}
+export interface iManualBalances {
+    balances: iBalance[];
+}
+export interface iIncrementedBalances {
+    startBalances: iBalance[];
+    incrementBadgeIdsBy: string | number;
+    incrementOwnershipTimesBy: string | number;
+}
+export interface iPredeterminedOrderCalculationMethod {
+    useOverallNumTransfers: boolean;
+    usePerToAddressNumTransfers: boolean;
+    usePerFromAddressNumTransfers: boolean;
+    usePerInitiatedByAddressNumTransfers: boolean;
+    useMerkleChallengeLeafIndex: boolean;
+    challengeTrackerId: string;
+}
+export interface iApprovalAmounts {
+    overallApprovalAmount: string | number;
+    perToAddressApprovalAmount: string | number;
+    perFromAddressApprovalAmount: string | number;
+    perInitiatedByAddressApprovalAmount: string | number;
+    amountTrackerId: string;
+}
+export interface iMaxNumTransfers {
+    overallMaxNumTransfers: string | number;
+    perToAddressMaxNumTransfers: string | number;
+    perFromAddressMaxNumTransfers: string | number;
+    perInitiatedByAddressMaxNumTransfers: string | number;
+    amountTrackerId: string;
+}
+export interface iUserIncomingApproval {
+    fromListId: string;
+    fromList: iAddressList;
+    initiatedByListId: string;
+    initiatedByList: iAddressList;
+    transferTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    approvalId: string;
+    uri?: string;
+    customData?: string;
+    approvalCriteria?: iIncomingApprovalCriteria;
+}
+export interface iIncomingApprovalCriteria {
+    mustOwnBadges?: iMustOwnBadges[];
+    zkProofs?: iZkProof[];
+    coinTransfers?: iCoinTransfer[];
+    merkleChallenges?: iMerkleChallenge[];
+    predeterminedBalances?: iPredeterminedBalances;
+    approvalAmounts?: iApprovalAmounts;
+    maxNumTransfers?: iMaxNumTransfers;
+    requireFromEqualsInitiatedBy?: boolean;
+    requireFromDoesNotEqualInitiatedBy?: boolean;
+}
+export interface iCollectionApproval {
+    toListId: string;
+    toList: iAddressList;
+    fromListId: string;
+    fromList: iAddressList;
+    initiatedByListId: string;
+    initiatedByList: iAddressList;
+    transferTimes: iUintRange[];
+    badgeIds: iUintRange[];
+    ownershipTimes: iUintRange[];
+    approvalId: string;
+    uri?: string;
+    customData?: string;
+    approvalCriteria?: iApprovalCriteria;
+}
+export interface iApprovalCriteria {
+    mustOwnBadges?: iMustOwnBadges[];
+    zkProofs?: iZkProof[];
+    coinTransfers?: iCoinTransfer[];
+    merkleChallenges?: iMerkleChallenge[];
+    predeterminedBalances?: iPredeterminedBalances;
+    approvalAmounts?: iApprovalAmounts;
+    maxNumTransfers?: iMaxNumTransfers;
+    requireToEqualsInitiatedBy?: boolean;
+    requireFromEqualsInitiatedBy?: boolean;
+    requireToDoesNotEqualInitiatedBy?: boolean;
+    requireFromDoesNotEqualInitiatedBy?: boolean;
+    overridesFromOutgoingApprovals?: boolean;
+    overridesToIncomingApprovals?: boolean;
+}
+export interface iUserBalanceStore {
+    balances: iBalance[];
+    incomingApprovals: iUserIncomingApproval[];
+    outgoingApprovals: iUserOutgoingApproval[];
+    userPermissions: iUserPermissions;
+    autoApproveSelfInitiatedOutgoingTransfers: boolean;
+    autoApproveSelfInitiatedIncomingTransfers: boolean;
+}
 //# sourceMappingURL=combined.d.ts.map