@monerium/sdk 2.12.0 → 2.13.0

package/README.md

@@ -1,3 +1,6 @@
+| [Monerium.com](https://monerium.com/) | [Monerium.app](https://monerium.app/) | [Monerium.dev](https://monerium.dev/) |
+| ------------------------------------- | ------------------------------------- | ------------------------------------- |
+
 # Monerium SDK Documentation
 
 Monerium connects your web3 wallet to any euro bank account with your personal IBAN.
@@ -5,6 +8,13 @@ All incoming euro payments are automatically minted as EURe tokens to your walle
 Sending EURe to traditional bank accounts is just as easy.
 With a single signature from your wallet, your EURe is burned and sent as Euros to any bank account.
 
+## Useful resources
+
+- [Documentation](./docs/generated/README.md)
+- [API Documentation](https://monerium.dev/api-docs)
+- [Developer portal](https://monerium.dev/')
+- [NPM](https://www.npmjs.com/package/@monerium/sdk)
+
 ## Table of Contents
 
 - [Installation](#installation)
@@ -49,7 +59,7 @@ yarn add @monerium/sdk
 
 ## Usage Examples
 
-We recommend starting in the [Developer Portal](https://monerium.dev/docs/welcome). There you will learn more about `client_id`'s and ways of authenticating.
+We recommend starting in the [Developer Portal](https://monerium.dev/docs/welcome). There, you will learn more about `client_id`'s and ways of authenticating.
 
 #### Initialize and authenticate using Client Credentials
 
@@ -87,7 +97,7 @@ API documentation:
 
 > Authorization Code Flow with PKCE is used for apps where direct user interaction is involved, and the application is running on an environment where the confidentiality of a secret cannot be safely maintained. It allows the application to authorize users without handling their passwords and mitigates the additional risk involved in this sort of delegation.
 
-First you have to navigate the user to the Monerium authentication flow. This can be done by generating a URL and redirecting the user to it. After the user has authenticated, Monerium will redirect back to your specified URI with a code. You can then finalize the authentication process by exchanging the code for access and refresh tokens.
+First, you have to navigate the user to the Monerium authentication flow. This can be done by generating a URL and redirecting the user to it. After the user has authenticated, Monerium will redirect back to your specified URI with a code. You can then finalize the authentication process by exchanging the code for access and refresh tokens.
 
 ```ts
 import { MoneriumClient } from '@monerium/sdk';
@@ -163,7 +173,9 @@ API documentation:
 const authCtx: AuthContext = await monerium.getAuthContext();
 
 // Fetching all accounts for a specific profile
-const { id: profileId, accounts }: Profile = await monerium.getProfile(authCtx.profiles[0].id);
+const { id: profileId, accounts }: Profile = await monerium.getProfile(
+  authCtx.profiles[0].id
+);
 
 // Fetching all balances for a specific profile
 const balances: Balances = await monerium.getBalances(profileId);
@@ -199,7 +211,7 @@ API documentation:
 
 #### Link a new address to Monerium
 
-It's important to understand, when interacting with a blockchain, the user needs to provide a signature in their wallet.
+It's important to understand when interacting with a blockchain, the user needs to provide a signature in their wallet.
 This signature is used to verify that the user is the owner of the wallet address.
 
 We recommend Viem as an Ethereum interface, see: https://viem.sh/docs/actions/wallet/signMessage.html
@@ -302,7 +314,8 @@ When placing orders with payouts above 15,000 EUR, a supporting document is requ
 
 ```ts
 // Upload a supporting document
-const supportingDocumentId: SupportingDoc = await uploadSupportingDocument(document);
+const supportingDocumentId: SupportingDoc =
+  await uploadSupportingDocument(document);
 ```
 
 Interfaces:
@@ -350,45 +363,27 @@ monerium.subscribeOrders(OrderState.processed, (notification) => {
 
 We are using [commitlint](https://github.com/conventional-changelog/commitlint/tree/master/@commitlint/config-conventional) to enforce that developers format the commit messages according to the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) guidelines.
 
-We are using Yarn as a package manager.
+We are using PNPM as a package manager.
 
-```sh
-# Install dependencies
-nx run sdk:init
+#### Development mode
 
-# Run Vite to build a production release distributable
-nx run sdk:build
-
-# Run Vite in watch mode to detect changes to files during development
-nx run sdk:build --watch
-
-# Update the docs. This will run the build and update the docs in the static folder.
-# Open static/index.html in your browser to view the docs. Refresh the page to see changes.
-nx run sdk:docs:watch
+```
+pnpm dev
 ```
 
-## Linking
+While in development mode, TypeScript declaration maps (`.d.ts.map`) are generated. TypeScript declaration maps are mainly used to quickly jump to type definitions in the context of a monorepo.
 
-For development, a package can be linked into another project. This is often useful to test out new features or when trying to debug an issue in a package that manifests itself in another project. run yarn link inside of the sdk project.
+#### Build
 
-```sh
-YARN_IGNORE_PATH=1 yarn link
 ```
-
-Use `yarn link "@monerium/sdk"` to link and test into your current project.
-
-```sh
-cd ../your-project
-yarn link "@monerium/sdk"
+pnpm build
 ```
 
-If you get an error that there is already a package called '@monerium/sdk' registered, but you can't find it and unlinking does nothing, remove it manually with `rm -rf ~/.config/yarn/link/@monerium` and try again.
-
 ### Documentation
 
-Refer to [Typedocs](https://typedoc.org/) syntaxes to use for this [documentation](https://monerium.github.io/js-sdk/).
+Refer to [Typedocs](https://typedoc.org/) syntaxes to use for this [documentation](https://monerium.github.io/js-monorepo/).
 
-There is a Github action that will automatically run on the successful release of the SDK. It will generate a static output of the documentation and push it to the `gh-pages` branch. The documentation is then available at https://monerium.github.io/js-sdk/.
+There is a Github action that will automatically run on the successful release of the SDK. It will generate a static output of the documentation and push it to the `gh-pages` branch. The documentation is then available at https://monerium.github.io/js-monorepo/.
 
 #### Publishing
 
@@ -401,9 +396,11 @@ Common questions developers have regarding the SDK.
 ## Support
 
 [Support](https://monerium.app/help)
+
 [Telegram](https://t.me/+lGtM1gY9zWthNGE8)
-[Github Issues](https://github.com/monerium/js-sdk/issues)
+
+[Github Issues](https://github.com/monerium/js-monorepo/issues)
 
 ## Release Notes
 
-https://github.com/monerium/js-sdk/releases
+https://github.com/monerium/js-monorepo/releases

package/dist/index.d.ts

@@ -1,4 +1,568 @@
-export { MoneriumClient } from './client';
-export { default as constants } from './constants';
-export * from './types';
-export { placeOrderMessage, rfc3339, getChain, getNetwork } from './utils';
+type Environment = {
+    api: string;
+    web: string;
+    wss: string;
+};
+type Config = {
+    environments: {
+        production: Environment;
+        sandbox: Environment;
+    };
+};
+type ENV = 'sandbox' | 'production';
+type EthereumTestnet = 'sepolia';
+type GnosisTestnet = 'chiado';
+type PolygonTestnet = 'amoy';
+type Chain = 'ethereum' | 'gnosis' | 'polygon';
+type Networks = EthereumTestnet | GnosisTestnet | PolygonTestnet | 'mainnet';
+type NetworkSemiStrict<C extends Chain> = C extends 'ethereum' ? EthereumTestnet | 'mainnet' : C extends 'gnosis' ? GnosisTestnet | 'mainnet' : C extends 'polygon' ? PolygonTestnet | 'mainnet' : never;
+type NetworkStrict<C extends Chain, E extends ENV> = E extends 'production' ? 'mainnet' : E extends 'sandbox' ? C extends 'ethereum' ? EthereumTestnet : C extends 'gnosis' ? GnosisTestnet : C extends 'polygon' ? PolygonTestnet : never : never;
+type Network<C extends Chain = Chain, E extends ENV = ENV> = C extends Chain ? E extends ENV ? NetworkStrict<C, E> & NetworkSemiStrict<C> : never : never;
+type ChainId = number | 1 | 11155111 | 100 | 137 | 10200 | 80002;
+declare enum Currency {
+    eur = "eur",
+    usd = "usd",
+    gbp = "gbp",
+    isk = "isk"
+}
+type TokenSymbol = 'EURe' | 'GBPe' | 'USDe' | 'ISKe';
+type Ticker = 'EUR' | 'GBP' | 'USD' | 'ISK';
+type AuthArgs = Omit<AuthCodeRequest, 'grant_type'> | Omit<RefreshTokenRequest, 'grant_type'> | Omit<ClientCredentialsRequest, 'grant_type'>;
+type OpenArgs = Omit<AuthCodeRequest, 'grant_type' | 'code' | 'code_verifier'> | Omit<RefreshTokenRequest, 'grant_type'> | Omit<ClientCredentialsRequest, 'grant_type'> | PKCERequestArgs;
+/** One of the options for the {@link AuthArgs}.
+ *
+ * [Auth endpoint in API documentation:](https://monerium.dev/api-docs#operation/auth).
+ * */
+interface AuthCodeRequest {
+    grant_type: 'authorization_code';
+    client_id: string;
+    code: string;
+    code_verifier: string;
+    redirect_uri: string;
+    scope?: string;
+}
+/** One of the options for the {@link AuthArgs}.
+ *
+ * [Auth endpoint in API documentation:](https://monerium.dev/api-docs#operation/auth).
+ * */
+interface RefreshTokenRequest {
+    grant_type: 'refresh_token';
+    client_id: string;
+    refresh_token: string;
+    scope?: string;
+}
+/** One of the options for the {@link AuthArgs}.
+ *
+ * [Auth endpoint in API documentation:](https://monerium.dev/api-docs#operation/auth).
+ * */
+interface ClientCredentialsRequest {
+    grant_type: 'client_credentials';
+    client_id: string;
+    client_secret: string;
+    scope?: string;
+}
+interface BearerProfile {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+    profile: string;
+    userId: string;
+}
+/**
+ * @returns A {@link PKCERequest} object with properties omitted that are automatically computed in by the SDK.
+ */
+type PKCERequestArgs = Omit<PKCERequest, 'code_challenge' | 'code_challenge_method' | 'response_type'>;
+type PKCERequest = {
+    /** the authentication flow client id of the application */
+    client_id: string;
+    /** the code challenge automatically generated by the SDK */
+    code_challenge: string;
+    /** the code challenge method for the authentication flow , handled by the SDK  */
+    code_challenge_method: 'S256';
+    /** the response type of the authentication flow, handled by the SDK */
+    response_type: 'code';
+    /** the state of the application */
+    state?: string;
+    /** the redirect uri of the application */
+    redirect_uri: string;
+    /** the scope of the application */
+    scope?: string;
+    /** the address of the wallet to automatically link */
+    address?: string;
+    /** the signature of the wallet to automatically link */
+    signature?: string;
+    /** @deprecated - Use chainId  */
+    network?: Network;
+    /** @deprecated - Use chainId */
+    chain?: Chain;
+    /** The network of the wallet to automatically link  */
+    chainId?: ChainId;
+};
+declare enum Method {
+    password = "password",
+    resource = "resource",
+    jwt = "jwt",
+    apiKey = "apiKey"
+}
+declare enum ProfileType {
+    corporate = "corporate",
+    personal = "personal"
+}
+declare enum Permission {
+    read = "read",
+    write = "write"
+}
+interface AuthProfile {
+    id: string;
+    type: ProfileType;
+    name: string;
+    perms: Permission[];
+}
+interface AuthContext {
+    userId: string;
+    email: string;
+    name: string;
+    roles: 'admin'[];
+    auth: {
+        method: Method;
+        subject: string;
+        verified: boolean;
+    };
+    defaultProfile: string;
+    profiles: AuthProfile[];
+}
+declare enum KYCState {
+    absent = "absent",
+    submitted = "submitted",
+    pending = "pending",
+    confirmed = "confirmed"
+}
+declare enum KYCOutcome {
+    approved = "approved",
+    rejected = "rejected",
+    unknown = "unknown"
+}
+declare enum AccountState {
+    requested = "requested",
+    approved = "approved",
+    pending = "pending"
+}
+interface KYC {
+    state: KYCState;
+    outcome: KYCOutcome;
+}
+declare enum PaymentStandard {
+    iban = "iban",
+    scan = "scan",
+    chain = "chain"
+}
+interface Identifier {
+    standard: PaymentStandard;
+    bic?: string;
+}
+interface Account {
+    address: string;
+    currency: Currency;
+    standard: PaymentStandard;
+    iban?: string;
+    network?: Network;
+    chain: Chain;
+    id?: string;
+    state?: AccountState;
+}
+interface Profile {
+    id: string;
+    name: string;
+    email: string;
+    kyc: KYC;
+    kind: ProfileType;
+    accounts: Account[];
+}
+interface Balance {
+    currency: Currency;
+    amount: string;
+}
+interface Balances {
+    id: string;
+    address: string;
+    chain: Chain;
+    network: Network;
+    balances: Balance[];
+}
+declare enum OrderKind {
+    redeem = "redeem",
+    issue = "issue"
+}
+declare enum OrderState {
+    placed = "placed",
+    pending = "pending",
+    processed = "processed",
+    rejected = "rejected"
+}
+interface Fee {
+    provider: 'satchel';
+    currency: Currency;
+    amount: string;
+}
+interface IBAN extends Identifier {
+    standard: PaymentStandard.iban;
+    iban: string;
+}
+interface CrossChain extends Identifier {
+    standard: PaymentStandard.chain;
+    address: string;
+    chainId: ChainId;
+    /** @deprecated - Use chainId */
+    chain?: Chain;
+    /** @deprecated - Use chainId */
+    network?: Network;
+}
+interface SCAN extends Identifier {
+    standard: PaymentStandard.scan;
+    sortCode: string;
+    accountNumber: string;
+}
+interface Individual {
+    firstName: string;
+    lastName: string;
+    country?: string;
+}
+interface Corporation {
+    companyName: string;
+    country: string;
+}
+interface Counterpart {
+    identifier: IBAN | SCAN | CrossChain;
+    details: Individual | Corporation;
+}
+interface OrderMetadata {
+    approvedAt: string;
+    processedAt: string;
+    rejectedAt: string;
+    state: OrderState;
+    placedBy: string;
+    placedAt: string;
+    receivedAmount: string;
+    sentAmount: string;
+}
+interface OrderFilter {
+    address?: string;
+    txHash?: string;
+    profile?: string;
+    memo?: string;
+    accountId?: string;
+    state?: OrderState;
+}
+interface Order {
+    id: string;
+    profile: string;
+    accountId: string;
+    address: string;
+    kind: OrderKind;
+    amount: string;
+    currency: Currency;
+    totalFee: string;
+    fees: Fee[];
+    counterpart: Counterpart;
+    memo: string;
+    rejectedReason: string;
+    supportingDocumentId: string;
+    meta: OrderMetadata;
+}
+/**
+ * Information about the EURe token on different networks.
+ */
+interface Token {
+    currency: Currency;
+    ticker: Ticker;
+    symbol: TokenSymbol;
+    chain: Chain;
+    network: Network;
+    /** The address of the EURe contract on this network */
+    address: string;
+    /** How many decimals this token supports */
+    decimals: number;
+}
+type NewOrder = NewOrderByAddress | NewOrderByAccountId;
+interface NewOrderCommon {
+    amount: string;
+    signature: string;
+    currency?: Currency /** Not needed right now, only EUR */;
+    counterpart: Counterpart;
+    message: string;
+    memo?: string;
+    supportingDocumentId?: string;
+}
+interface NewOrderByAddress extends NewOrderCommon {
+    address: string;
+    /** @deprecated - Use 'chainId' */
+    chain?: Chain;
+    /** @deprecated - Use 'chainId' */
+    network?: Network;
+    chainId: ChainId;
+}
+interface NewOrderByAccountId extends NewOrderCommon {
+    accountId: string;
+}
+interface SupportingDocMetadata {
+    uploadedBy: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SupportingDoc {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    hash: string;
+    meta: SupportingDocMetadata;
+}
+interface CurrencyAccounts {
+    /** @deprecated - Use 'chainId' */
+    network?: Network;
+    /** @deprecated - Use 'chainId' */
+    chain?: Chain;
+    chainId: ChainId;
+    currency: Currency;
+}
+interface LinkAddress {
+    address: string;
+    message: string;
+    signature: string;
+    accounts: CurrencyAccounts[];
+    /** @deprecated - Use 'chainId' */
+    network?: Network;
+    /** @deprecated - Use 'chainId' */
+    chain?: Chain;
+    chainId?: ChainId;
+}
+interface OrderNotification {
+    id: string;
+    profile: string;
+    accountId: string;
+    address: string;
+    kind: string;
+    amount: string;
+    currency: string;
+    totalFee: string;
+    fees: Fee[];
+    counterpart: Counterpart;
+    memo: string;
+    rejectedReason: string;
+    supportingDocumentId: string;
+    meta: OrderMetadata;
+}
+type MoneriumEvent = OrderState;
+type MoneriumEventListener = (notification: OrderNotification) => void;
+type ClassOptions = {
+    environment?: ENV;
+} & BearerTokenCredentials;
+interface AuthFlowOptions {
+    clientId?: string;
+    redirectUrl?: string;
+    address?: string;
+    signature?: string;
+    chainId?: ChainId;
+    state?: string;
+}
+interface ClientCredentials {
+    clientId: string;
+    clientSecret: string;
+}
+interface AuthorizationCodeCredentials {
+    clientId: string;
+    redirectUrl: string;
+}
+type BearerTokenCredentials = ClientCredentials | AuthorizationCodeCredentials;
+
+declare class MoneriumClient {
+    #private;
+    /**
+     * The PKCE code verifier
+     * @deprecated, use localStorage, will be removed in v3
+     * @hidden
+     * */
+    codeVerifier?: string;
+    /**
+     * The bearer profile will be available after authentication, it includes the `access_token` and `refresh_token`
+     * */
+    bearerProfile?: BearerProfile;
+    isAuthorized: boolean;
+    /**
+     * The state parameter is used to maintain state between the request and the callback.
+     * */
+    state: string | undefined;
+    /**
+     * @defaultValue `sandbox`
+     * @example
+     * new MoneriumClient() // defaults to `sandbox`
+     *
+     * new MoneriumClient('production')
+     *
+     * new MoneriumClient({
+     *  environment: 'sandbox',
+     *  clientId: 'your-client-id',
+     *  redirectUrl: 'your-redirect-url'
+     * })
+     * */
+    constructor(envOrOptions?: ENV | ClassOptions);
+    /**
+     * Construct the url to the authorization code flow,
+     * Code Verifier needed for the code challenge is stored in local storage
+     * For automatic wallet link, add the following properties: `address`, `signature` & `chainId`
+     * @returns string
+     * {@link https://monerium.dev/api-docs#operation/auth}
+     * @category Auth
+     */
+    authorize(client?: AuthFlowOptions): Promise<void>;
+    /**
+     * Get access to the API
+     * @param {AuthorizationCodeCredentials | ClientCredentials} client - the client credentials
+     * @returns boolean to indicate if access has been granted
+     * @category Auth
+     */
+    getAccess(client?: AuthorizationCodeCredentials | ClientCredentials): Promise<boolean>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/auth-context}
+     * @category Auth
+     */
+    getAuthContext(): Promise<AuthContext>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/profile}
+     * @param {string} profileId - the id of the profile to fetch.
+     * @category Profiles
+     */
+    getProfile(profileId: string): Promise<Profile>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/profile-balances}
+     * @param {string=} profileId - the id of the profile to fetch balances.
+     * @category Accounts
+     */
+    getBalances(profileId?: string): Promise<Balances[]>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/orders}
+     * @category Orders
+     */
+    getOrders(filter?: OrderFilter): Promise<Order[]>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/order}
+     * @category Orders
+     */
+    getOrder(orderId: string): Promise<Order>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/tokens}
+     * @category Tokens
+     */
+    getTokens(): Promise<Token[]>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/profile-addresses}
+     * @category Accounts
+     */
+    linkAddress(profileId: string, body: LinkAddress): Promise<unknown>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/post-orders}
+     * @category Orders
+     */
+    placeOrder(order: NewOrder, profileId?: string): Promise<Order>;
+    /**
+     * {@link https://monerium.dev/api-docs#operation/supporting-document}
+     * @category Orders
+     */
+    uploadSupportingDocument(document: File): Promise<SupportingDoc>;
+    /**
+     * Connects to the order notifications socket
+     * @category Orders
+     */
+    connectOrderSocket(): Promise<void>;
+    /**
+     * Subscribes to the order notifications socket
+     * @category Orders
+     */
+    subscribeToOrderNotifications: () => WebSocket;
+    /**
+     * Cleanups the socket and the subscriptions
+     * @category Auth
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Revokes access
+     * @category Auth
+     */
+    revokeAccess(): Promise<void>;
+    /**
+     * Subscribe to MoneriumEvent to receive notifications using the Monerium API (WebSocket)
+     * We are setting a subscription map because we need the user to have a token to start the WebSocket connection
+     * {@link https://monerium.dev/api-docs#operation/profile-orders-notifications}
+     * @param event The event to subscribe to
+     * @param handler The handler to be called when the event is triggered
+     * @category Orders
+     */
+    subscribeOrders(event: MoneriumEvent, handler: MoneriumEventListener): void;
+    /**
+     * Unsubscribe from MoneriumEvent and close the socket if there are no more subscriptions
+     * @param event The event to unsubscribe from
+     * @category Orders
+     */
+    unsubscribeOrders(event: MoneriumEvent): void;
+    /**
+     * @deprecated since v2.6.4, will be removed in 2.7.2+, use {@link getAccess} instead.
+     * @hidden
+     */
+    auth: (args: AuthArgs) => Promise<BearerProfile>;
+    /**
+     * @deprecated since v2.7.1, will be removed in 2.7.2+, use {@link getAccess} instead.
+     * @hidden
+     */
+    connect: (args: AuthArgs) => Promise<BearerProfile>;
+    /**
+     * @deprecated since v2.6.4, will be removed in 2.7.2+, use {@link authorize} instead.
+     * @hidden
+     */
+    getAuthFlowURI: (args: PKCERequestArgs) => string;
+    /**
+     * @deprecated since v2.0.7, will be removed in 2.7.2+, use {@link getAuthFlowURI} instead.
+     * @hidden
+     */
+    pkceRequest: (args: PKCERequestArgs) => string;
+    /**
+     * @hidden
+     */
+    getEnvironment: () => Environment;
+}
+
+declare const _default: {
+    /**
+     * The message used to link addresses.
+     */
+    LINK_MESSAGE: string;
+    /**
+     * The key used to store the code verifier in the local storage.
+     */
+    STORAGE_CODE_VERIFIER: string;
+    /**
+     * The key used to store the refresh token in the local storage.
+     */
+    STORAGE_REFRESH_TOKEN: string;
+};
+
+declare const rfc3339: (d: Date) => string;
+/**
+ * The message to be signed when placing an order.
+ *
+ * @returns string
+ */
+declare const placeOrderMessage: (amount: string | number, receiver: string, chainId?: number, currency?: 'eur' | 'gbp' | 'usd' | 'isk') => string;
+/**
+ * Get the corresponding Monerium SDK Chain from the current chain id
+ * @returns The Chain
+ */
+declare const getChain: (chainId: number) => Chain;
+/**
+ * Get the corresponding Monerium SDK Network from the current chain id
+ * @returns The Network
+ * @deprecated network will be removed from Monerium API in the near future.
+ */
+declare const getNetwork: (chainId: number) => Networks;
+
+export { type Account, AccountState, type AuthArgs, type AuthCodeRequest, type AuthContext, type AuthFlowOptions, type AuthProfile, type AuthorizationCodeCredentials, type Balance, type Balances, type BearerProfile, type BearerTokenCredentials, type Chain, type ChainId, type ClassOptions, type ClientCredentials, type ClientCredentialsRequest, type Config, type Corporation, type Counterpart, type CrossChain, Currency, type CurrencyAccounts, type ENV, type Environment, type EthereumTestnet, type Fee, type GnosisTestnet, type IBAN, type Identifier, type Individual, type KYC, KYCOutcome, KYCState, type LinkAddress, Method, MoneriumClient, type MoneriumEvent, type MoneriumEventListener, type Network, type NetworkSemiStrict, type NetworkStrict, type Networks, type NewOrder, type NewOrderByAccountId, type NewOrderByAddress, type NewOrderCommon, type OpenArgs, type Order, type OrderFilter, OrderKind, type OrderMetadata, type OrderNotification, OrderState, type PKCERequest, type PKCERequestArgs, PaymentStandard, Permission, type PolygonTestnet, type Profile, ProfileType, type RefreshTokenRequest, type SCAN, type SupportingDoc, type SupportingDocMetadata, type Ticker, type Token, type TokenSymbol, _default as constants, MoneriumClient as default, getChain, getNetwork, placeOrderMessage, rfc3339 };