@yoroi/types
Version:
The Yoroi Types package of Yoroi SDK
211 lines (210 loc) • 9.98 kB
JavaScript
"use strict";
import { LinksErrorExtraParamsDenied, LinksErrorForbiddenParamsProvided, LinksErrorParamsValidationFailed, LinksErrorRequiredParamsMissing, LinksErrorSchemeNotImplemented, LinksErrorUnsupportedAuthority, LinksErrorUnsupportedVersion } from './links/errors';
import { ApiHttpStatusCode } from './api/status-code';
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 { ExchangeProviderNotFoundError, ExchangeUnknownError, ExchangeValidationError } from './exchange/errors';
import { PortfolioTokenApplication, PortfolioTokenNature, PortfolioTokenPropertyType, PortfolioTokenSource, PortfolioTokenStatus, PortfolioTokenType } from './portfolio/token';
import { ChainNetwork } from './chain/network';
import { NumbersErrorInvalidAtomicValue } from './numbers/errors';
import { AppErrorInvalidState, AppErrorLibraryFailed, AppErrorWrongPassword } from './app/errors';
import { PortfolioEventManagerOn } from './portfolio/event';
import { ExplorersExplorer } from './explorers/explorer';
import { NetworkBlockchains } from './network/manager';
import { PortfolioTokenActivityWindow } from './portfolio/activity';
import { AppLoggerLevel } from './app/logger';
import { ScanErrorUnknown, ScanErrorUnknownContent } from './scan/errors';
import { ClaimApiErrorsAlreadyClaimed, ClaimApiErrorsExpired, ClaimApiErrorsInvalidRequest, ClaimApiErrorsNotFound, ClaimApiErrorsRateLimited, ClaimApiErrorsTooEarly } from './claim/errors';
import { PortfolioTokenHistoryPeriod } from './portfolio/history';
import { NotificationTrigger } from './notifications/manager';
import { SwapDex } from './swap/dex';
import { SwapAggregator } from './swap/aggregator';
import { SwapProtocol } from './swap/protocol';
export let App;
(function (_App) {
let Errors;
(function (_Errors) {
class InvalidState extends AppErrorInvalidState {}
_Errors.InvalidState = InvalidState;
class WrongPassword extends AppErrorWrongPassword {}
_Errors.WrongPassword = WrongPassword;
class LibraryError extends AppErrorLibraryFailed {}
_Errors.LibraryError = LibraryError;
})(Errors || (Errors = _App.Errors || (_App.Errors = {})));
let Logger;
(function (_Logger) {
const Level = _Logger.Level = AppLoggerLevel;
})(Logger || (Logger = _App.Logger || (_App.Logger = {})));
})(App || (App = {}));
export let Swap;
(function (_Swap) {
const Aggregator = _Swap.Aggregator = SwapAggregator;
const Protocol = _Swap.Protocol = SwapProtocol;
const Dex = _Swap.Dex = SwapDex;
})(Swap || (Swap = {}));
export let Balance;
export let Links;
(function (_Links) {
let Errors;
(function (_Errors2) {
class ExtraParamsDenied extends LinksErrorExtraParamsDenied {}
_Errors2.ExtraParamsDenied = ExtraParamsDenied;
class ForbiddenParamsProvided extends LinksErrorForbiddenParamsProvided {}
_Errors2.ForbiddenParamsProvided = ForbiddenParamsProvided;
class RequiredParamsMissing extends LinksErrorRequiredParamsMissing {}
_Errors2.RequiredParamsMissing = RequiredParamsMissing;
class ParamsValidationFailed extends LinksErrorParamsValidationFailed {}
_Errors2.ParamsValidationFailed = ParamsValidationFailed;
class UnsupportedAuthority extends LinksErrorUnsupportedAuthority {}
_Errors2.UnsupportedAuthority = UnsupportedAuthority;
class UnsupportedVersion extends LinksErrorUnsupportedVersion {}
_Errors2.UnsupportedVersion = UnsupportedVersion;
class SchemeNotImplemented extends LinksErrorSchemeNotImplemented {}
_Errors2.SchemeNotImplemented = SchemeNotImplemented;
})(Errors || (Errors = _Links.Errors || (_Links.Errors = {})));
})(Links || (Links = {}));
export let Api;
(function (_Api) {
const HttpStatusCode = _Api.HttpStatusCode = ApiHttpStatusCode;
let Errors;
(function (_Errors3) {
class BadRequest extends ApiErrorBadRequest {}
_Errors3.BadRequest = BadRequest;
class NotFound extends ApiErrorNotFound {}
_Errors3.NotFound = NotFound;
class Conflict extends ApiErrorConflict {}
_Errors3.Conflict = Conflict;
class Forbidden extends ApiErrorForbidden {}
_Errors3.Forbidden = Forbidden;
class Gone extends ApiErrorGone {}
_Errors3.Gone = Gone;
class TooEarly extends ApiErrorTooEarly {}
_Errors3.TooEarly = TooEarly;
class TooManyRequests extends ApiErrorTooManyRequests {}
_Errors3.TooManyRequests = TooManyRequests;
class Unauthorized extends ApiErrorUnauthorized {}
_Errors3.Unauthorized = Unauthorized;
class ServerSide extends ApiErrorServerSide {}
_Errors3.ServerSide = ServerSide;
class Network extends ApiErrorNetwork {}
_Errors3.Network = Network;
class Unknown extends ApiErrorUnknown {}
_Errors3.Unknown = Unknown;
class InvalidState extends ApiErrorInvalidState {}
_Errors3.InvalidState = InvalidState;
class ResponseMalformed extends ApiErrorResponseMalformed {}
_Errors3.ResponseMalformed = ResponseMalformed;
})(Errors || (Errors = _Api.Errors || (_Api.Errors = {})));
})(Api || (Api = {}));
export let Numbers;
(function (_Numbers) {
let Errors;
(function (_Errors4) {
class InvalidAtomicValue extends NumbersErrorInvalidAtomicValue {}
_Errors4.InvalidAtomicValue = InvalidAtomicValue;
})(Errors || (Errors = _Numbers.Errors || (_Numbers.Errors = {})));
})(Numbers || (Numbers = {}));
export let Resolver;
(function (_Resolver) {
const NameServer = _Resolver.NameServer = ResolverNameServer;
let Errors;
(function (_Errors5) {
class InvalidResponse extends ResolverErrorInvalidResponse {}
_Errors5.InvalidResponse = InvalidResponse;
class InvalidDomain extends ResolverErrorInvalidDomain {}
_Errors5.InvalidDomain = InvalidDomain;
class NotFound extends ResolverErrorNotFound {}
_Errors5.NotFound = NotFound;
class UnsupportedTld extends ResolverErrorUnsupportedTld {}
_Errors5.UnsupportedTld = UnsupportedTld;
class Expired extends ResolverErrorUnsupportedTld {}
_Errors5.Expired = Expired;
class WrongBlockchain extends ResolverErrorWrongBlockchain {}
_Errors5.WrongBlockchain = WrongBlockchain;
})(Errors || (Errors = _Resolver.Errors || (_Resolver.Errors = {})));
})(Resolver || (Resolver = {}));
export let Transfer;
export let Explorers;
(function (_Explorers) {
const Explorer = _Explorers.Explorer = ExplorersExplorer;
})(Explorers || (Explorers = {}));
export let Portfolio;
(function (_Portfolio) {
let Event;
(function (_Event) {
const ManagerOn = _Event.ManagerOn = PortfolioEventManagerOn;
})(Event || (Event = _Portfolio.Event || (_Portfolio.Event = {})));
let Token;
(function (_Token) {
const Type = _Token.Type = PortfolioTokenType;
const PropertyType = _Token.PropertyType = PortfolioTokenPropertyType;
const Application = _Token.Application = PortfolioTokenApplication;
const Source = _Token.Source = PortfolioTokenSource;
const Nature = _Token.Nature = PortfolioTokenNature;
const Status = _Token.Status = PortfolioTokenStatus;
const ActivityWindow = _Token.ActivityWindow = PortfolioTokenActivityWindow;
const HistoryPeriod = _Token.HistoryPeriod = PortfolioTokenHistoryPeriod;
})(Token || (Token = _Portfolio.Token || (_Portfolio.Token = {})));
})(Portfolio || (Portfolio = {}));
export let Chain;
(function (_Chain) {
const Network = _Chain.Network = ChainNetwork;
})(Chain || (Chain = {}));
export let HW;
export let Wallet;
export let Exchange;
(function (_Exchange) {
let Errors;
(function (_Errors6) {
class Validation extends ExchangeValidationError {}
_Errors6.Validation = Validation;
class Unknown extends ExchangeUnknownError {}
_Errors6.Unknown = Unknown;
class ProviderNotFound extends ExchangeProviderNotFoundError {}
_Errors6.ProviderNotFound = ProviderNotFound;
})(Errors || (Errors = _Exchange.Errors || (_Exchange.Errors = {})));
})(Exchange || (Exchange = {}));
export let Network;
(function (_Network) {
const Blockchains = _Network.Blockchains = NetworkBlockchains;
})(Network || (Network = {}));
export let Notifications;
(function (_Notifications) {
const Trigger = _Notifications.Trigger = NotificationTrigger;
})(Notifications || (Notifications = {}));
export let Scan;
(function (_Scan) {
let Errors;
(function (_Errors7) {
class UnknownContent extends ScanErrorUnknownContent {}
_Errors7.UnknownContent = UnknownContent;
class Unknown extends ScanErrorUnknown {}
_Errors7.Unknown = Unknown;
})(Errors || (Errors = _Scan.Errors || (_Scan.Errors = {})));
})(Scan || (Scan = {}));
export let Claim;
(function (_Claim) {
let Api;
(function (_Api3) {
let Errors;
(function (_Errors8) {
class AlreadyClaimed extends ClaimApiErrorsAlreadyClaimed {}
_Errors8.AlreadyClaimed = AlreadyClaimed;
class Expired extends ClaimApiErrorsExpired {}
_Errors8.Expired = Expired;
class InvalidRequest extends ClaimApiErrorsInvalidRequest {}
_Errors8.InvalidRequest = InvalidRequest;
class NotFound extends ClaimApiErrorsNotFound {}
_Errors8.NotFound = NotFound;
class RateLimited extends ClaimApiErrorsRateLimited {}
_Errors8.RateLimited = RateLimited;
class TooEarly extends ClaimApiErrorsTooEarly {}
_Errors8.TooEarly = TooEarly;
})(Errors || (Errors = _Api3.Errors || (_Api3.Errors = {})));
})(Api || (Api = _Claim.Api || (_Claim.Api = {})));
})(Claim || (Claim = {}));
export * from './helpers/types';
export * from './helpers/storage';
export * from './api/cardano';
//# sourceMappingURL=index.js.map