@yoroi/types/lib/typescript/index.d.ts

The Yoroi Types package of Yoroi SDK

import { BalanceAmount, BalanceAmounts, BalanceCardanoMetadatas, BalanceQuantity, BalanceToken } from './balance/token';
import { SwapApi, SwapCancelRequest, SwapCancelResponse, SwapCreateRequest, SwapCreateResponse, SwapEstimateRequest, SwapEstimateResponse, SwapLimitOptionsRequest, SwapLimitOptionsResponse, SwapSplit } from './swap/api';
import { AppStorage, AppStorageFolderName, AppStorageKeyManager } from './app/storage';
import { AppMultiStorage, AppMultiStorageOptions } from './app/multi-storage';
import { NumberLocale } from './intl/numbers';
import { ResolverAddressesResponse, ResolverAddressResponse, ResolverApi, ResolverStrategy } from './resolver/api';
import { ResolverManager } from './resolver/manager';
import { ResolverReceiver } from './resolver/receiver';
import { ResolverStorage } from './resolver/storage';
import { LinksLink, LinksModule, LinksUriConfig, LinksUriRules, LinksWebCardanoUriConfig } from './links/cardano';
import { LinksErrorExtraParamsDenied, LinksErrorForbiddenParamsProvided, LinksErrorParamsValidationFailed, LinksErrorRequiredParamsMissing, LinksErrorSchemeNotImplemented, LinksErrorUnsupportedAuthority, LinksErrorUnsupportedVersion } from './links/errors';
import { ApiRequestRecordWithCache, ApiResponseRecordWithCache } from './api/cache';
import { ApiHttpStatusCode } from './api/status-code';
import { ApiResponse, ApiResponseError, ApiResponseSuccess } from './api/response';
import { ApiErrorBadRequest, ApiErrorConflict, ApiErrorForbidden, ApiErrorGone, ApiErrorInvalidState, ApiErrorNetwork, ApiErrorNotFound, ApiErrorResponseMalformed, ApiErrorServerSide, ApiErrorTooEarly, ApiErrorTooManyRequests, ApiErrorUnauthorized, ApiErrorUnknown } from './api/errors';
import { ResolverNameServer } from './resolver/name-server';
import { ResolverErrorInvalidDomain, ResolverErrorInvalidResponse, ResolverErrorNotFound, ResolverErrorUnsupportedTld, ResolverErrorWrongBlockchain } from './resolver/errors';
import { AppApi, AppFrontendFeesResponse, AppFrontendFeeTier } from './api/app';
import { ApiFtMetadata, ApiFtMetadataRecord, ApiFtRecords, ApiFutureToken, ApiFutureTokenRecords, ApiMetadataFile, ApiNftMetadata, ApiNftMetadataRecord, ApiNftRecords, ApiOffChainMetadataRecord, ApiOffChainMetadataRequest, ApiOffChainMetadataResponse, ApiOnChainMetadataRecord, ApiOnChainMetadataRequest, ApiOnChainMetadataResponse, ApiTokenId, ApiTokenIdentity, ApiTokenRegistryEntry, ApiTokenSupplyRecord, ApiTokenSupplyResponse, ApiTokeSupplyRequest, ApiUtxoData, ApiUtxoDataAsset, ApiUtxoDataRequest } from './api/cardano';
import { TransferEntry, TransferTarget, TransferTargets } from './transfer/state';
import { AppObservableMultiStorage, AppObservableStorage } from './app/observable-storage';
import { AppCacheInfo, AppCacheRecord, AppCacheRow } from './app/cache';
import { AppObserverManager, AppObserverSubscribe, AppSubscriber } from './app/observer-manager';
import { CardanoAddress, CardanoMetadata, CardanoSignedTx, CardanoStaking, CardanoTokenId, CardanoTxInfo, CardanoUnsignedTx, CardanoVoting, ChainCardanoProtocolParams, ChainCardanoBestBlock } from './chain/cardano';
import { ExchangeBlockchainCode } from './exchange/blockchain';
import { ExchangeManagerOptions } from './exchange/build';
import { ExchangeCoin } from './exchange/coin';
import { ExchangeFiat } from './exchange/fiat';
import { ExchangeReferralUrlQueryStringParams } from './exchange/query-string';
import { ExchangeProviderNotFoundError, ExchangeUnknownError, ExchangeValidationError } from './exchange/errors';
import { ExchangeOrderType } from './exchange/order-type';
import { ExchangeProvider } from './exchange/provider';
import { ExchangeApi } from './exchange/api';
import { ExchangeManager } from './exchange/manager';
import { LinksBrowserLaunchDappUrlParams, LinksExchangeShowCreateResultParams, LinksPartnerInfoParams, LinksTransferRequestAdaParams, LinksTransferRequestAdaWithLinkParams, LinksYoroiAction, LinksYoroiActionInfo, LinksYoroiModule, LinksYoroiUriConfig } from './links/yoroi';
import { PortfolioTokenApplication, PortfolioTokenId, PortfolioTokenNature, PortfolioTokenPropertyType, PortfolioTokenSource, PortfolioTokenStatus, PortfolioTokenType } from './portfolio/token';
import { PortfolioTokenDiscovery } from './portfolio/discovery';
import { PortfolioTokenInfo } from './portfolio/info';
import { PortfolioPrimaryBreakdown, PortfolioTokenAmount, PortfolioTokenAmountRecords } from './portfolio/amount';
import { PortfolioTokenPrice } from './portfolio/price';
import { ChainNetwork, ChainSupportedNetworks } from './chain/network';
import { NumbersErrorInvalidAtomicValue } from './numbers/errors';
import { NumbersAtomicValue } from './numbers/atomic-value';
import { AppErrorInvalidState, AppErrorLibraryFailed, AppErrorWrongPassword } from './app/errors';
import { PortfolioApi, PortfolioApiTokenActivityResponse, PortfolioApiTokenDiscoveryResponse, PortfolioApiTokenHistoryResponse, PortfolioApiTokenInfosResponse, PortfolioApiTokenTraitsResponse } from './portfolio/api';
import { PortfolioEventBalanceManager, PortfolioEventBalanceManagerHydrate, PortfolioEventBalanceManagerRefresh, PortfolioEventBalanceManagerSync, PortfolioEventManagerOn, PortfolioEventSourceId, PortfolioEventTokenManager, PortfolioEventTokenManagerHydrate, PortfolioEventTokenManagerSync } from './portfolio/event';
import { PortfolioStorageBalance, PortfolioStorageToken } from './portfolio/storage';
import { PortfolioManagerBalance, PortfolioManagerToken } from './portfolio/manager';
import { PortfolioFungibilityFilter, PortfolioTokenBalances } from './portfolio/balances';
import { AppQueueTask, AppQueueTaskManager } from './app/queue-task-manager';
import { ExplorersManager } from './explorers/manager';
import { ExplorersExplorer } from './explorers/explorer';
import { PortfolioTokenTrait, PortfolioTokenTraits } from './portfolio/traits';
import { HWDeviceInfo, HWDeviceObj, HWFeatures } from './hw/hw';
import { WalletAddressMode, WalletImplementation } from './wallet/wallet';
import { WalletMeta } from './wallet/meta';
import { NetworkApi, NetworkBlockchains, NetworkConfig, NetworkEpochInfo, NetworkEpochProgress, NetworkEraConfig, NetworkManager } from './network/manager';
import { PortfolioTokenActivity, PortfolioTokenActivityRecord, PortfolioTokenActivityWindow } from './portfolio/activity';
import { AppLoggerEntry, AppLoggerLevel, AppLoggerManager, AppLoggerMessage, AppLoggerMetadata, AppLoggerTransporter, AppLoggerTransporterOptions } from './app/logger';
import { ScanErrorUnknown, ScanErrorUnknownContent } from './scan/errors';
import { ScanAction, ScanActionClaim, ScanActionLaunchUrl, ScanActionSendOnlyReceiver, ScanActionSendSinglePt, ScanFeature } from './scan/actions';
import { ClaimInfo, ClaimManager, ClaimStatus } from './claim/claim';
import { ClaimApiErrorsAlreadyClaimed, ClaimApiErrorsExpired, ClaimApiErrorsInvalidRequest, ClaimApiErrorsNotFound, ClaimApiErrorsRateLimited, ClaimApiErrorsTooEarly } from './claim/errors';
import { ClaimApiClaimTokensRequestPayload, ClaimApiClaimTokensResponse } from './claim/api';
import { PortfolioTokenHistory, PortfolioTokenHistoryPeriod } from './portfolio/history';
import { BannerNotificationEvent, NotificationConfig, NotificationEvent, NotificationGroup, NotificationManager, NotificationManagerMakerProps, NotificationPrimaryTokenPriceChangedEvent, NotificationRewardsUpdatedEvent, NotificationTransactionReceivedEvent, NotificationTrigger, PushNotificationEvent } from './notifications/manager';
import { NumbersRatio } from './numbers/ratio';
import { SwapStorage } from './swap/storage';
import { SwapManager, SwapManagerSettings, SwapManagerMaker } from './swap/manager';
import { SwapDex } from './swap/dex';
import { SwapOrder } from './swap/order';
import { SwapAggregator } from './swap/aggregator';
import { SwapProtocol } from './swap/protocol';
import { PortfolioCurrencyConfig, PortfolioCurrencyConfigBySymbol, PortfolioCurrencySymbol } from './portfolio/currency';
export declare namespace App {
    namespace Errors {
        class InvalidState extends AppErrorInvalidState {
        }
        class WrongPassword extends AppErrorWrongPassword {
        }
        class LibraryError extends AppErrorLibraryFailed {
        }
    }
    interface Storage<IsAsync extends boolean = true, K extends string = string> extends AppStorage<IsAsync, K> {
    }
    type StorageKeyManager<T = unknown, R = T, Key extends string = string> = AppStorageKeyManager<T, R, Key>;
    type StorageFolderName = AppStorageFolderName;
    interface MultiStorage<T, IsAsync extends boolean = true, K extends string = string> extends AppMultiStorage<T, IsAsync, K> {
    }
    interface ObservableStorage<IsAsync extends boolean = true, K extends string = string> extends AppObservableStorage<IsAsync, K> {
    }
    interface ObservableMultiStorage<T, IsAsync extends boolean = true, K extends string = string> extends AppObservableMultiStorage<T, IsAsync, K> {
    }
    type MultiStorageOptions<T, IsAsync extends boolean = true, K extends string = string> = AppMultiStorageOptions<T, IsAsync, K>;
    type ObserverManager<T> = AppObserverManager<T>;
    type Subscriber<T> = AppSubscriber<T>;
    type ObserverSubscribe<T> = AppObserverSubscribe<T>;
    type QueueTask = AppQueueTask;
    type QueueTaskManager = AppQueueTaskManager;
    type CacheInfo = AppCacheInfo;
    interface CacheRecord<T> extends AppCacheRecord<T> {
    }
    interface CacheRow<T, K extends string = string> extends AppCacheRow<T, K> {
    }
    interface Api extends AppApi {
    }
    type FrontendFeeTier = AppFrontendFeeTier;
    type FrontendFeesResponse = AppFrontendFeesResponse;
    namespace Logger {
        type Level = AppLoggerLevel;
        const Level: typeof AppLoggerLevel;
        type Message = AppLoggerMessage;
        type Metadata = AppLoggerMetadata;
        type Transporter = AppLoggerTransporter;
        type TransporterOptions = AppLoggerTransporterOptions;
        type Entry = AppLoggerEntry;
        type Manager = AppLoggerManager;
    }
}
export declare namespace Swap {
    type Api = SwapApi;
    type Order = SwapOrder;
    type Aggregator = SwapAggregator;
    const Aggregator: Readonly<{
        readonly Muesliswap: "muesliswap";
        readonly Dexhunter: "dexhunter";
    }>;
    type Protocol = SwapProtocol;
    const Protocol: Readonly<{
        readonly Cswap: "cswap";
        readonly Minswap_v1: "minswap-v1";
        readonly Minswap_v2: "minswap-v2";
        readonly Minswap_stable: "minswap-stable";
        readonly Muesliswap_v2: "muesliswap-v2";
        readonly Muesliswap_clp: "muesliswap-clp";
        readonly Spectrum_v1: "spectrum-v1";
        readonly Sundaeswap_v1: "sundaeswap-v1";
        readonly Sundaeswap_v3: "sundaeswap-v3";
        readonly Teddy_v1: "teddy-v1";
        readonly Vyfi_v1: "vyfi-v1";
        readonly Wingriders_v1: "wingriders-v1";
        readonly Wingriders_v2: "wingriders-v2";
        readonly Splash_v1: "splash-v1";
        readonly Unsupported: "unsupported";
    }>;
    type Dex = SwapDex;
    const Dex: typeof SwapDex;
    type LimitOptionsRequest = SwapLimitOptionsRequest;
    type LimitOptionsResponse = SwapLimitOptionsResponse;
    type CancelRequest = SwapCancelRequest;
    type CancelResponse = SwapCancelResponse;
    type EstimateRequest = SwapEstimateRequest;
    type EstimateResponse = SwapEstimateResponse;
    type CreateRequest = SwapCreateRequest;
    type CreateResponse = SwapCreateResponse;
    type Split = SwapSplit;
    type Storage = SwapStorage;
    type Manager = SwapManager;
    type ManagerMaker = SwapManagerMaker;
    type ManagerSettings = SwapManagerSettings;
}
export declare namespace Balance {
    type Token = BalanceToken;
    type TokenInfo = BalanceToken['info'];
    type TokenPrice = BalanceToken['price'];
    type TokenSupply = BalanceToken['supply'];
    type TokenStatus = BalanceToken['status'];
    type CardanoMetadatas = BalanceCardanoMetadatas;
    type Quantity = BalanceQuantity;
    type Amount = BalanceAmount;
    type Amounts = BalanceAmounts;
}
export declare namespace Links {
    type YoroiModule = LinksYoroiModule;
    interface UriConfig extends LinksUriConfig {
    }
    interface WebCardanoUriConfig extends LinksWebCardanoUriConfig {
    }
    interface YoroiUriConfig extends LinksYoroiUriConfig {
    }
    type PartnerInfoSchema = LinksPartnerInfoParams;
    type ExchangeShowCreateResultParams = LinksExchangeShowCreateResultParams;
    type TransferRequestAdaWithLinkParams = LinksTransferRequestAdaWithLinkParams;
    type TransferRequestAdaParams = LinksTransferRequestAdaParams;
    type BrowserLaunchDappUrlParams = LinksBrowserLaunchDappUrlParams;
    type YoroiActionInfo = LinksYoroiActionInfo;
    type YoroiAction = LinksYoroiAction;
    interface Rules extends LinksUriRules {
    }
    type Link<T extends LinksUriConfig> = LinksLink<T>;
    type Module<T extends LinksUriConfig> = LinksModule<T>;
    namespace Errors {
        class ExtraParamsDenied extends LinksErrorExtraParamsDenied {
        }
        class ForbiddenParamsProvided extends LinksErrorForbiddenParamsProvided {
        }
        class RequiredParamsMissing extends LinksErrorRequiredParamsMissing {
        }
        class ParamsValidationFailed extends LinksErrorParamsValidationFailed {
        }
        class UnsupportedAuthority extends LinksErrorUnsupportedAuthority {
        }
        class UnsupportedVersion extends LinksErrorUnsupportedVersion {
        }
        class SchemeNotImplemented extends LinksErrorSchemeNotImplemented {
        }
    }
}
export declare namespace Api {
    type ResponseError = ApiResponseError;
    type ResponseSuccess<T> = ApiResponseSuccess<T>;
    type Response<T> = ApiResponse<T>;
    type ResponseWithCache<T> = ApiResponseRecordWithCache<T>;
    type RequestWithCache<T> = ApiRequestRecordWithCache<T>;
    type HttpStatusCode = ApiHttpStatusCode;
    const HttpStatusCode: typeof ApiHttpStatusCode;
    namespace Errors {
        class BadRequest extends ApiErrorBadRequest {
        }
        class NotFound extends ApiErrorNotFound {
        }
        class Conflict extends ApiErrorConflict {
        }
        class Forbidden extends ApiErrorForbidden {
        }
        class Gone extends ApiErrorGone {
        }
        class TooEarly extends ApiErrorTooEarly {
        }
        class TooManyRequests extends ApiErrorTooManyRequests {
        }
        class Unauthorized extends ApiErrorUnauthorized {
        }
        class ServerSide extends ApiErrorServerSide {
        }
        class Network extends ApiErrorNetwork {
        }
        class Unknown extends ApiErrorUnknown {
        }
        class InvalidState extends ApiErrorInvalidState {
        }
        class ResponseMalformed extends ApiErrorResponseMalformed {
        }
    }
    namespace Cardano {
        type OffChainMetadataRequest = ApiOffChainMetadataRequest;
        type OnChainMetadataRecord = ApiOnChainMetadataRecord;
        type OffChainMetadataResponse = ApiOffChainMetadataResponse;
        type OnChainMetadataRequest = ApiOnChainMetadataRequest;
        type OffChainMetadataRecord = ApiOffChainMetadataRecord;
        type OnChainMetadataResponse = ApiOnChainMetadataResponse;
        type TokenSupplyRequest = ApiTokeSupplyRequest;
        type TokenSupplyRecord = ApiTokenSupplyRecord;
        type TokenIdentity = ApiTokenIdentity;
        type TokenSupplyResponse = ApiTokenSupplyResponse;
        type FutureToken = ApiFutureToken;
        type FutureTokenRecords = ApiFutureTokenRecords;
        type FtMetadata = ApiFtMetadata;
        type FtMetadataRecord = ApiFtMetadataRecord;
        interface FtRecords extends ApiFtRecords {
        }
        type TokenRegistryEntry = ApiTokenRegistryEntry;
        type NftMetadata = ApiNftMetadata;
        type NftMetadataRecord = ApiNftMetadataRecord;
        interface NftRecords extends ApiNftRecords {
        }
        type MetadataFile = ApiMetadataFile;
        type TokenId = ApiTokenId;
        type ProtocolParams = ChainCardanoProtocolParams;
        type BestBlock = ChainCardanoBestBlock;
        type UtxoDataRequest = ApiUtxoDataRequest;
        type UtxoDataAsset = ApiUtxoDataAsset;
        type UtxoData = ApiUtxoData;
        interface Api {
            getProtocolParams: () => Promise<ChainCardanoProtocolParams>;
            getBestBlock: () => Promise<ChainCardanoBestBlock>;
            getUtxoData: (request: UtxoDataRequest) => Promise<ApiUtxoData>;
        }
    }
}
export declare namespace Numbers {
    type Locale = NumberLocale;
    type AtomicValue = NumbersAtomicValue;
    type Ratio = NumbersRatio;
    namespace Errors {
        class InvalidAtomicValue extends NumbersErrorInvalidAtomicValue {
        }
    }
}
export declare namespace Resolver {
    interface Api extends ResolverApi {
    }
    type Manager = ResolverManager;
    type NameServer = ResolverNameServer;
    const NameServer: typeof ResolverNameServer;
    type Receiver = ResolverReceiver;
    type AddressResponse = ResolverAddressResponse;
    type AddressesResponse = ResolverAddressesResponse;
    type Strategy = ResolverStrategy;
    type Storage = ResolverStorage;
    namespace Errors {
        class InvalidResponse extends ResolverErrorInvalidResponse {
        }
        class InvalidDomain extends ResolverErrorInvalidDomain {
        }
        class NotFound extends ResolverErrorNotFound {
        }
        class UnsupportedTld extends ResolverErrorUnsupportedTld {
        }
        class Expired extends ResolverErrorUnsupportedTld {
        }
        class WrongBlockchain extends ResolverErrorWrongBlockchain {
        }
    }
}
export declare namespace Transfer {
    type Entry = TransferEntry;
    type Target = TransferTarget;
    type Targets = TransferTargets;
}
export declare namespace Explorers {
    type Manager = ExplorersManager;
    const Explorer: {
        readonly Cardanoscan: "cardanoscan";
        readonly Cexplorer: "cexplorer";
    };
    type Explorer = ExplorersExplorer;
}
export declare namespace Portfolio {
    type PrimaryBreakdown = PortfolioPrimaryBreakdown;
    type FungibilityFilter = PortfolioFungibilityFilter;
    namespace Currency {
        type Symbol = PortfolioCurrencySymbol;
        type Config = PortfolioCurrencyConfig;
        type ConfigBySymbol = PortfolioCurrencyConfigBySymbol;
    }
    namespace Event {
        type SourceId = PortfolioEventSourceId;
        type TokenManager = PortfolioEventTokenManager;
        type BalanceManager = PortfolioEventBalanceManager;
        type ManagerOn = PortfolioEventManagerOn;
        const ManagerOn: typeof PortfolioEventManagerOn;
        type TokenManagerSync = PortfolioEventTokenManagerSync;
        type TokenManagerHydrate = PortfolioEventTokenManagerHydrate;
        type BalanceManagerSync = PortfolioEventBalanceManagerSync;
        type BalanceManagerHydrate = PortfolioEventBalanceManagerHydrate;
        type BalanceManagerRefresh = PortfolioEventBalanceManagerRefresh;
    }
    namespace Api {
        type TokenInfosResponse = PortfolioApiTokenInfosResponse;
        type TokenDiscoveryResponse = PortfolioApiTokenDiscoveryResponse;
        type TokenTraitsResponse = PortfolioApiTokenTraitsResponse;
        type TokenActivityResponse = PortfolioApiTokenActivityResponse;
        type TokenHistoryResponse = PortfolioApiTokenHistoryResponse;
        type Api = PortfolioApi;
    }
    namespace Storage {
        type Token = PortfolioStorageToken;
        type Balance = PortfolioStorageBalance;
    }
    namespace Manager {
        type Token = PortfolioManagerToken;
        type Balance = PortfolioManagerBalance;
    }
    namespace Token {
        type Trait = PortfolioTokenTrait;
        type Traits = PortfolioTokenTraits;
        type Balances = PortfolioTokenBalances;
        type Amount = PortfolioTokenAmount;
        type AmountRecords = PortfolioTokenAmountRecords;
        type Id = PortfolioTokenId;
        type Type = PortfolioTokenType;
        const Type: typeof PortfolioTokenType;
        type PropertyType = PortfolioTokenPropertyType;
        const PropertyType: typeof PortfolioTokenPropertyType;
        type Application = PortfolioTokenApplication;
        const Application: typeof PortfolioTokenApplication;
        type Source = PortfolioTokenSource;
        const Source: typeof PortfolioTokenSource;
        type Nature = PortfolioTokenNature;
        const Nature: typeof PortfolioTokenNature;
        type Status = PortfolioTokenStatus;
        const Status: typeof PortfolioTokenStatus;
        type Info = PortfolioTokenInfo;
        type Discovery = PortfolioTokenDiscovery;
        type Price = PortfolioTokenPrice;
        type Activity = PortfolioTokenActivity;
        type ActivityWindow = PortfolioTokenActivityWindow;
        const ActivityWindow: typeof PortfolioTokenActivityWindow;
        type ActivityRecord = PortfolioTokenActivityRecord;
        type History = PortfolioTokenHistory;
        type HistoryPeriod = PortfolioTokenHistoryPeriod;
        const HistoryPeriod: typeof PortfolioTokenHistoryPeriod;
    }
}
export declare namespace Chain {
    type Network = ChainNetwork;
    const Network: typeof ChainNetwork;
    type SupportedNetworks = ChainSupportedNetworks;
    namespace Cardano {
        type UnsignedTx = CardanoUnsignedTx;
        type SignedTx = CardanoSignedTx;
        type TxInfo = CardanoTxInfo;
        type Metadata = CardanoMetadata;
        type Staking = CardanoStaking;
        type Voting = CardanoVoting;
        type Address = CardanoAddress;
        type TokenId = CardanoTokenId;
        type ProtocolParams = ChainCardanoProtocolParams;
        type BestBlock = ChainCardanoBestBlock;
    }
}
export declare namespace HW {
    type Features = HWFeatures;
    type DeviceInfo = HWDeviceInfo;
    type DeviceObj = HWDeviceObj;
}
export declare namespace Wallet {
    type Implementation = WalletImplementation;
    type AddressMode = WalletAddressMode;
    type Meta = WalletMeta;
}
export declare namespace Exchange {
    type BlockchainCode = ExchangeBlockchainCode;
    type Manager = ExchangeManager;
    type ManagerOptions = ExchangeManagerOptions;
    type Coin = ExchangeCoin;
    type Fiat = ExchangeFiat;
    type OrderType = ExchangeOrderType;
    type Provider = ExchangeProvider;
    type ReferralUrlQueryStringParams = ExchangeReferralUrlQueryStringParams;
    interface Api extends ExchangeApi {
    }
    namespace Errors {
        class Validation extends ExchangeValidationError {
        }
        class Unknown extends ExchangeUnknownError {
        }
        class ProviderNotFound extends ExchangeProviderNotFoundError {
        }
    }
}
export declare namespace Network {
    type Api = NetworkApi;
    type Manager = NetworkManager;
    type Config = NetworkConfig;
    type Blockchains = NetworkBlockchains;
    const Blockchains: typeof NetworkBlockchains;
    type EraConfig = NetworkEraConfig;
    type EpochInfo = NetworkEpochInfo;
    type EpochProgress = NetworkEpochProgress;
}
export declare namespace Notifications {
    type Config = NotificationConfig;
    type Event = NotificationEvent;
    type Group = NotificationGroup;
    type Manager = NotificationManager;
    type ManagerMakerProps = NotificationManagerMakerProps;
    type TransactionReceivedEvent = NotificationTransactionReceivedEvent;
    type RewardsUpdatedEvent = NotificationRewardsUpdatedEvent;
    type PushEvent = PushNotificationEvent;
    type BannerEvent = BannerNotificationEvent;
    type PrimaryTokenPriceChangedEvent = NotificationPrimaryTokenPriceChangedEvent;
    const Trigger: typeof NotificationTrigger;
    type Trigger = NotificationTrigger;
}
export declare namespace Scan {
    namespace Errors {
        class UnknownContent extends ScanErrorUnknownContent {
        }
        class Unknown extends ScanErrorUnknown {
        }
    }
    type Feature = ScanFeature;
    type Action = ScanAction;
    type ActionClaim = ScanActionClaim;
    type ActionSendOnlyReceiver = ScanActionSendOnlyReceiver;
    type ActionSendSinglePt = ScanActionSendSinglePt;
    type ActionScanLaunchUrl = ScanActionLaunchUrl;
}
export declare namespace Claim {
    namespace Api {
        namespace Errors {
            class AlreadyClaimed extends ClaimApiErrorsAlreadyClaimed {
            }
            class Expired extends ClaimApiErrorsExpired {
            }
            class InvalidRequest extends ClaimApiErrorsInvalidRequest {
            }
            class NotFound extends ClaimApiErrorsNotFound {
            }
            class RateLimited extends ClaimApiErrorsRateLimited {
            }
            class TooEarly extends ClaimApiErrorsTooEarly {
            }
        }
        type ClaimTokensRequestPayload = ClaimApiClaimTokensRequestPayload;
        type ClaimTokensResponse = ClaimApiClaimTokensResponse;
    }
    type Status = ClaimStatus;
    type Info = ClaimInfo;
    type Manager = ClaimManager;
}
export * from './helpers/types';
export * from './helpers/storage';
export * from './api/cardano';
//# sourceMappingURL=index.d.ts.map