squarefi-bff-api-module 1.32.1 → 1.32.2

package/dist/api/auth.d.ts

@@ -0,0 +1,29 @@
+import { API } from './types/types';
+export declare const telegramSignInPath = "/auth/sign-in/telegram";
+export declare const telegramSignUpPath = "/auth/sign-up/telegram";
+export declare const refreshTokenPath = "/auth/refresh/refresh-token";
+export declare const auth: {
+    otp: {
+        verify: {
+            email: (email: string, token: string) => Promise<API.Auth.VerifyOtp.Response>;
+            phone: (phone: string, token: string) => Promise<API.Auth.VerifyOtp.Response>;
+        };
+    };
+    signin: {
+        omni: {
+            email: (data: API.Auth.SignIn.Omni.Email.OTP.Request) => Promise<API.Auth.Tokens>;
+            phone: ({ phone, ...data }: API.Auth.SignIn.Omni.Phone.OTP.Request) => Promise<API.Auth.Tokens>;
+        };
+        byType: (data: API.Auth.SignIn.ByType.Request) => Promise<API.Auth.Tokens>;
+        telegram: (data: API.Auth.Telegram.Signin.Request) => Promise<API.Auth.Telegram.Signin.Response>;
+        password: (email: string, password: string) => Promise<API.Auth.Tokens>;
+    };
+    signup: {
+        byType: (data: API.Auth.SignUp.ByType.Request) => Promise<API.Auth.Tokens>;
+        password: (email: string, password: string) => Promise<API.Auth.Tokens>;
+        telegram: (data: API.Auth.Telegram.Signup.Request) => Promise<API.Auth.Telegram.Signup.Response>;
+    };
+    refresh: {
+        refresh_token: (data: API.Auth.RefreshToken.Request) => Promise<API.Auth.RefreshToken.Response>;
+    };
+};

package/dist/api/auth.js

@@ -0,0 +1,59 @@
+import { apiClientV2 } from '../utils/apiClientFactory';
+import { convertPhoneToSupabaseFormat } from '../utils/converters';
+export const telegramSignInPath = '/auth/sign-in/telegram'; // V2 path
+// export const telegramSignInPath = '/auth/signin/telegram'; // V1 path
+export const telegramSignUpPath = '/auth/sign-up/telegram';
+export const refreshTokenPath = '/auth/refresh/refresh-token';
+export const auth = {
+    otp: {
+        verify: {
+            email: (email, token) => apiClientV2.postRequest('/auth/verify/email/otp', {
+                data: { email, token, type: 'email' },
+                context: { bypassUnauthorizedHandler: true },
+            }),
+            phone: (phone, token) => apiClientV2.postRequest('/auth/verify/phone/otp', {
+                data: {
+                    phone: convertPhoneToSupabaseFormat(phone),
+                    token,
+                    type: 'sms',
+                },
+                context: { bypassUnauthorizedHandler: true },
+            }),
+        },
+    },
+    signin: {
+        omni: {
+            email: (data) => apiClientV2.postRequest('/auth/sign-in/omni/email/otp', {
+                data,
+                context: { bypassUnauthorizedHandler: true },
+            }),
+            phone: ({ phone, ...data }) => apiClientV2.postRequest('/auth/sign-in/omni/phone/otp', {
+                data: { phone: convertPhoneToSupabaseFormat(phone), ...data },
+                context: { bypassUnauthorizedHandler: true },
+            }),
+        },
+        byType: (data) => apiClientV2.postRequest('/auth/sign-in', {
+            data,
+            context: { bypassUnauthorizedHandler: true },
+        }),
+        telegram: (data) => apiClientV2.postRequest(telegramSignInPath, { data }),
+        password: (email, password) => apiClientV2.postRequest('/auth/sign-in/password/email', {
+            data: { email, password },
+            context: { bypassUnauthorizedHandler: true },
+        }),
+    },
+    signup: {
+        byType: (data) => apiClientV2.postRequest('/auth/sign-up', {
+            data,
+            context: { bypassUnauthorizedHandler: true },
+        }),
+        password: (email, password) => apiClientV2.postRequest('/auth/sign-up/password/email', {
+            data: { email, password },
+            context: { bypassUnauthorizedHandler: true },
+        }),
+        telegram: (data) => apiClientV2.postRequest(telegramSignUpPath, { data }),
+    },
+    refresh: {
+        refresh_token: (data) => apiClientV2.postRequest(refreshTokenPath, { data }),
+    },
+};

package/dist/api/bank-data.d.ts

@@ -0,0 +1,4 @@
+import { API } from './types/types';
+export declare const bankData: {
+    getBankDataByAccountNumber: (params: API.BankData.GetBankDataByAccountNumber.Request) => Promise<API.BankData.GetBankDataByAccountNumber.Response>;
+};

package/dist/api/bank-data.js

@@ -0,0 +1,6 @@
+import { apiClientV2 } from '../utils/apiClientFactory';
+export const bankData = {
+    getBankDataByAccountNumber: (params) => apiClientV2.getRequest(`/bank-data`, {
+        params,
+    }),
+};

package/dist/api/counterparties.d.ts

@@ -0,0 +1,14 @@
+import { API } from './types/types';
+export declare const counterparties: {
+    getAll: ({ wallet_id, ...params }: API.Counterparties.List.Request) => Promise<API.Counterparties.List.Response>;
+    getById: ({ wallet_id, counterparty_account_id, }: API.Counterparties.GetById.Request) => Promise<API.Counterparties.GetById.Response>;
+    create: ({ wallet_id, ...data }: API.Counterparties.Create.Request) => Promise<API.Counterparties.Create.Response>;
+    update: ({ wallet_id, counterparty_account_id, ...data }: API.Counterparties.Update.Request) => Promise<API.Counterparties.Update.Response>;
+    destinations: {
+        getAll: ({ wallet_id, counterparty_account_id, ...params }: API.Counterparties.Destination.List.Request) => Promise<API.Counterparties.Destination.List.Response>;
+        getById: ({ wallet_id, counterparty_account_id, counterparty_destination_id, }: API.Counterparties.Destination.Detail.Request) => Promise<API.Counterparties.Destination.Detail.Response>;
+        create: ({ wallet_id, counterparty_account_id, ...data }: API.Counterparties.Destination.Create.Request) => Promise<API.Counterparties.Destination.Create.Response>;
+        update: ({ wallet_id, counterparty_account_id, counterparty_destination_id, ...data }: API.Counterparties.Destination.Update.Request) => Promise<API.Counterparties.Destination.Update.Response>;
+        delete: ({ wallet_id, counterparty_account_id, counterparty_destination_id, }: API.Counterparties.Destination.Delete.Request) => Promise<void>;
+    };
+};

package/dist/api/counterparties.js

@@ -0,0 +1,16 @@
+import { apiClientV2 } from '../utils/apiClientFactory';
+export const counterparties = {
+    getAll: ({ wallet_id, ...params }) => apiClientV2.getRequest(`/counterparties/${wallet_id}`, {
+        params,
+    }),
+    getById: ({ wallet_id, counterparty_account_id, }) => apiClientV2.getRequest(`/counterparties/${wallet_id}/${counterparty_account_id}`),
+    create: ({ wallet_id, ...data }) => apiClientV2.postRequest(`/counterparties/${wallet_id}`, { data }),
+    update: ({ wallet_id, counterparty_account_id, ...data }) => apiClientV2.patchRequest(`/counterparties/${wallet_id}/${counterparty_account_id}`, { data }),
+    destinations: {
+        getAll: ({ wallet_id, counterparty_account_id, ...params }) => apiClientV2.getRequest(`/counterparties/${wallet_id}/${counterparty_account_id}/destinations`, { params }),
+        getById: ({ wallet_id, counterparty_account_id, counterparty_destination_id, }) => apiClientV2.getRequest(`/counterparties/${wallet_id}/${counterparty_account_id}/destinations/${counterparty_destination_id}`),
+        create: ({ wallet_id, counterparty_account_id, ...data }) => apiClientV2.postRequest(`/counterparties/${wallet_id}/${counterparty_account_id}/destinations`, { data }),
+        update: ({ wallet_id, counterparty_account_id, counterparty_destination_id, ...data }) => apiClientV2.patchRequest(`/counterparties/${wallet_id}/${counterparty_account_id}/destinations/${counterparty_destination_id}`, { data }),
+        delete: ({ wallet_id, counterparty_account_id, counterparty_destination_id, }) => apiClientV2.deleteRequest(`/counterparties/${wallet_id}/${counterparty_account_id}/destinations/${counterparty_destination_id}`),
+    },
+};

package/dist/api/developer.d.ts

@@ -0,0 +1,12 @@
+import { API } from './types/types';
+export declare const developer: {
+    apiKeys: {
+        getAll: () => Promise<API.Developer.ApiCode.ApiCode[]>;
+        create: (data: API.Developer.ApiCode.Create.Request) => Promise<API.Developer.ApiCode.Create.Response>;
+        rotate: (data: API.Developer.ApiCode.Rotate.Request) => Promise<API.Developer.ApiCode.Rotate.Response>;
+        update: (data: API.Developer.ApiCode.Update.Request) => Promise<void>;
+    };
+    vendors: {
+        list: () => Promise<API.Developer.Vendors.Vendor[]>;
+    };
+};

package/dist/api/developer.js

@@ -0,0 +1,12 @@
+import { apiClientV1 } from '../utils/apiClientFactory';
+export const developer = {
+    apiKeys: {
+        getAll: () => apiClientV1.getRequest('/developer/access/list'),
+        create: (data) => apiClientV1.postRequest('/developer/access/create', { data }),
+        rotate: (data) => apiClientV1.postRequest(`/developer/access/rotate`, { data }),
+        update: (data) => apiClientV1.postRequest(`/developer/access/update`, { data }),
+    },
+    vendors: {
+        list: () => apiClientV1.getRequest('/developer/vendors/list'),
+    },
+};

package/dist/api/exchange.d.ts

@@ -0,0 +1,14 @@
+import { API } from './types/types';
+import { OrderType } from '../constants';
+type IExchangeByOrderType = {
+    getByFromCurrency: (from_uuid: string) => Promise<API.Exchange.Exchange[]>;
+    getByToCurrency: (to_uuid: string) => Promise<API.Exchange.Exchange[]>;
+    getByOrderType: () => Promise<API.Exchange.Exchange[]>;
+};
+type IExchangeModule = {
+    byOrderType: {
+        [key in OrderType]: IExchangeByOrderType;
+    };
+};
+export declare const exchange: IExchangeModule;
+export {};

package/dist/api/exchange.js

@@ -0,0 +1,20 @@
+import { apiClientV1 } from '../utils/apiClientFactory';
+import { OrderType } from '../constants';
+const createOrderTypeMethods = (orderType) => ({
+    getByFromCurrency: (from_uuid) => apiClientV1.getRequest('/exchange/', {
+        params: { from_uuid, order_type: orderType },
+    }),
+    getByToCurrency: (to_uuid) => apiClientV1.getRequest('/exchange/', {
+        params: { to_uuid, order_type: orderType },
+    }),
+    getByOrderType: () => apiClientV1.getRequest('/exchange/', {
+        params: { order_type: orderType },
+    }),
+});
+const orderTypes = Object.values(OrderType);
+export const exchange = {
+    byOrderType: orderTypes.reduce((acc, orderType) => {
+        acc[orderType] = createOrderTypeMethods(orderType);
+        return acc;
+    }, {}),
+};

package/dist/api/frontend.d.ts

@@ -0,0 +1,11 @@
+import { API } from './types/types';
+export declare const frontend: {
+    access: {
+        keys: {
+            create: (data: API.Frontend.Access.Keys.Create.Request) => Promise<API.Frontend.Access.Keys.Create.Response>;
+            list: () => Promise<API.Frontend.Access.Keys.List.Response>;
+            regenerate: (key_id: string) => Promise<API.Frontend.Access.Keys.Regenerate.Response>;
+            revoke: (key_id: string) => Promise<API.Frontend.Access.Keys.Revoke.Response>;
+        };
+    };
+};

package/dist/api/frontend.js

@@ -0,0 +1,11 @@
+import { apiClientV1 } from '../utils/apiClientFactory';
+export const frontend = {
+    access: {
+        keys: {
+            create: (data) => apiClientV1.postRequest('/frontend/access/keys', { data }),
+            list: () => apiClientV1.getRequest('/frontend/access/keys'),
+            regenerate: (key_id) => apiClientV1.postRequest(`/frontend/access/keys/${key_id}/regenerate`),
+            revoke: (key_id) => apiClientV1.deleteRequest(`/frontend/access/keys/${key_id}`),
+        },
+    },
+};

package/dist/api/index.d.ts

@@ -0,0 +1,38 @@
+import { auth } from './auth';
+import { bankData } from './bank-data';
+import { counterparties } from './counterparties';
+import { developer } from './developer';
+import { exchange } from './exchange';
+import { frontend } from './frontend';
+import { issuing } from './issuing';
+import { kyc } from './kyc';
+import { list } from './list';
+import { orders } from './orders';
+import { persona } from './persona';
+import { storage } from './storage';
+import { tenants } from './tenants';
+import { totp } from './totp';
+import { user } from './user';
+import { virtualAccounts } from './virtual-accounts';
+import { wallets } from './wallets';
+type Api = {
+    auth: typeof auth;
+    bankData: typeof bankData;
+    counterparties: typeof counterparties;
+    developer: typeof developer;
+    exchange: typeof exchange;
+    frontend: typeof frontend;
+    issuing: typeof issuing;
+    kyc: typeof kyc;
+    list: typeof list;
+    orders: typeof orders;
+    persona: typeof persona;
+    storage: typeof storage;
+    tenants: typeof tenants;
+    totp: typeof totp;
+    user: typeof user;
+    virtualAccounts: typeof virtualAccounts;
+    wallets: typeof wallets;
+};
+export declare const squarefi_bff_api_client: Api;
+export {};

package/dist/api/index.js

@@ -0,0 +1,36 @@
+import { auth } from './auth';
+import { bankData } from './bank-data';
+import { counterparties } from './counterparties';
+import { developer } from './developer';
+import { exchange } from './exchange';
+import { frontend } from './frontend';
+import { issuing } from './issuing';
+import { kyc } from './kyc';
+import { list } from './list';
+import { orders } from './orders';
+import { persona } from './persona';
+import { storage } from './storage';
+import { tenants } from './tenants';
+import { totp } from './totp';
+import { user } from './user';
+import { virtualAccounts } from './virtual-accounts';
+import { wallets } from './wallets';
+export const squarefi_bff_api_client = {
+    auth,
+    bankData,
+    counterparties,
+    developer,
+    exchange,
+    frontend,
+    issuing,
+    kyc,
+    list,
+    orders,
+    persona,
+    storage,
+    tenants,
+    totp,
+    user,
+    virtualAccounts,
+    wallets,
+};

package/dist/api/issuing.d.ts

@@ -0,0 +1,64 @@
+import { API } from './types/types';
+export declare const issuing: {
+    cards: {
+        create: {
+            standAloneCard: {
+                prepaid: (data: API.Cards.Create.StandAloneRequest) => Promise<API.Cards.Create.StandAloneResponse>;
+                balance: (data: API.Cards.Create.StandAloneRequest) => Promise<API.Cards.Create.ExtendedSubAccountResponse>;
+            };
+            subAccountCard: (data: API.Cards.Create.SubAccountRequest) => Promise<API.Cards.Create.ExtendedSubAccountResponse>;
+        };
+        byWalletUuid: {
+            getAll: (params: API.Cards.CardsList.Request.ByWalletUuid) => Promise<API.Cards.CardsList.Response>;
+            getBySubaccountType: (params: API.Cards.CardsList.Request.BySubaccountAndWalletUuid) => Promise<API.Cards.CardsList.Response>;
+            getBySubAccount: (params: API.Cards.CardsList.Request.BySubAccountAndWalletId) => Promise<API.Cards.CardsList.Response>;
+        };
+        getById: (card_id: string) => Promise<API.Cards.IssuingCardDetailItem>;
+        sensitiveData: {
+            encrypted: {
+                secretKey: {
+                    get: (card_id: string) => Promise<API.Cards.SensitiveData>;
+                };
+            };
+            otp: {
+                get: (card_id: string) => Promise<API.Cards.OTP>;
+            };
+        };
+        freeze: (card_id: string) => Promise<API.Cards.IssuingCardDetailItem>;
+        unfreeze: (card_id: string) => Promise<API.Cards.IssuingCardDetailItem>;
+        close: (card_id: string) => Promise<void>;
+        limits: {
+            update: (card_id: string, data: API.Cards.Limits.UpdateRequest) => Promise<API.Cards.IssuingCardDetailItem>;
+        };
+        rename: (card_id: string, nick_name: string) => Promise<API.Cards.IssuingCardDetailItem>;
+    };
+    transactions: {
+        getByCardId: (card_id: string, limit?: number, offset?: number) => Promise<API.Cards.TransactionsList>;
+        getBySubAccountId: (fiat_account_id: string, limit?: number, offset?: number) => Promise<API.Cards.TransactionsList>;
+        csv: {
+            getByCardId: (card_id: string) => Promise<string>;
+            getBySubAccountId: (sub_account_id: string) => Promise<string>;
+        };
+    };
+    sub_accounts: {
+        list: {
+            withCards: {
+                getSinglecards: (wallet_uuid: string, limit: number, offset: number) => Promise<API.Issuing.SubAccounts.WithCards.Response>;
+                getAll: (wallet_uuid: string, limit: number, offset: number) => Promise<API.Issuing.SubAccounts.WithCards.Response>;
+            };
+            withoutCards: {
+                getAll: ({ wallet_uuid, ...params }: API.Issuing.SubAccounts.WithoutCards.Request) => Promise<API.Issuing.SubAccounts.WithoutCards.Response>;
+            };
+        };
+        getByUuid: (uuid: string) => Promise<API.Issuing.SubAccounts.SubAccount>;
+        create: (wallet_id: string, program_id: string) => Promise<API.Issuing.SubAccounts.SubAccount>;
+        transactions: {
+            get: ({ sub_account_id, ...params }: API.Issuing.SubAccounts.TransactionList.Request) => Promise<API.Issuing.SubAccounts.TransactionList.Response>;
+        };
+    };
+    config: {
+        programs: {
+            getAll: (params: API.Issuing.Programs.Request) => Promise<API.Issuing.Programs.Response>;
+        };
+    };
+};

package/dist/api/issuing.js

@@ -0,0 +1,140 @@
+import { apiClientV1 } from '../utils/apiClientFactory';
+import { defaultPaginationParams } from '../constants';
+import { makeSecureRequest } from '../utils/encrypt';
+export const issuing = {
+    cards: {
+        create: {
+            standAloneCard: {
+                prepaid: (data) => apiClientV1.postRequest('/issuing/cards/create', { data }),
+                balance: async (data) => {
+                    const { id: sub_account_id } = await issuing.sub_accounts.create(data.wallet_id, data.program_id);
+                    const response = await apiClientV1.postRequest('/issuing/cards/balance', {
+                        data: {
+                            ...data,
+                            sub_account_id,
+                        },
+                    });
+                    return {
+                        ...response,
+                        sub_account_id,
+                    };
+                },
+            },
+            subAccountCard: async (data) => {
+                const response = await apiClientV1.postRequest('/issuing/cards/balance', {
+                    data,
+                });
+                return {
+                    ...response,
+                    sub_account_id: data.sub_account_id,
+                };
+            },
+        },
+        byWalletUuid: {
+            getAll: (params) => apiClientV1.getRequest('/issuing/cards', {
+                params,
+            }),
+            getBySubaccountType: (params) => apiClientV1.getRequest('/issuing/cards', {
+                params,
+            }),
+            getBySubAccount: (params) => apiClientV1.getRequest('/issuing/cards', {
+                params,
+            }),
+        },
+        // getById: (card_id: string) => apiClientV1.getRequest<API.Cards.IssuingCardDetailItem>(`/issuing/cards/${card_id}`),
+        getById: async (card_id) => {
+            const card = await apiClientV1.getRequest(`/issuing/cards/${card_id}`);
+            const subAccountData = await issuing.sub_accounts.getByUuid(card.fiat_account.id);
+            return {
+                ...card,
+                fiat_account: { ...subAccountData, type: card.fiat_account.type },
+            };
+        },
+        sensitiveData: {
+            // get: (card_id: string) => apiClientV1.getRequest<API.Cards.SensitiveData>(`/issuing/cards/${card_id}/sensitive`), deprecated from v1.13.1
+            encrypted: {
+                secretKey: {
+                    get: async (card_id) => {
+                        const serverPublicKeyEnv = process.env.SERVER_PUBLIC_KEY_BASE64;
+                        const callback = (props) => apiClientV1.postRequest(`/issuing/cards/${card_id}/sensitive/secretkey`, {
+                            data: props,
+                        });
+                        if (!serverPublicKeyEnv) {
+                            throw new Error('SERVER_PUBLIC_KEY_BASE64 is not set');
+                        }
+                        const encryptedData = await makeSecureRequest({
+                            callback,
+                            publicKey: serverPublicKeyEnv,
+                        });
+                        return encryptedData;
+                    },
+                },
+            },
+            otp: {
+                // have to update
+                get: (card_id) => apiClientV1.getRequest(`/vcards/cards/${card_id}/sensitive/otp`),
+            },
+        },
+        freeze: (card_id) => apiClientV1.patchRequest(`/issuing/cards/${card_id}/freeze`),
+        unfreeze: (card_id) => apiClientV1.patchRequest(`/issuing/cards/${card_id}/unfreeze`),
+        close: (card_id) => apiClientV1.deleteRequest(`/issuing/cards/${card_id}`),
+        limits: {
+            update: (card_id, data) => apiClientV1.patchRequest(`/issuing/cards/${card_id}/limits`, { data }),
+        },
+        rename: (card_id, nick_name) => apiClientV1.patchRequest(`/issuing/cards/${card_id}/update`, {
+            data: { nick_name, request_id: crypto.randomUUID() },
+        }),
+    },
+    transactions: {
+        getByCardId: (card_id, limit = defaultPaginationParams.limit, offset = defaultPaginationParams.offset) => apiClientV1.getRequest(`/issuing/transactions/`, {
+            params: { limit, offset, card_id, new_scheme: true },
+        }),
+        getBySubAccountId: (fiat_account_id, limit = defaultPaginationParams.limit, offset = defaultPaginationParams.offset) => apiClientV1.getRequest(`/issuing/transactions/`, {
+            params: { limit, offset, fiat_account_id, new_scheme: true },
+        }),
+        csv: {
+            getByCardId: (card_id) => apiClientV1.getRequest(`/issuing/transactions/csv`, {
+                params: { card_id },
+            }),
+            getBySubAccountId: (sub_account_id) => apiClientV1.getRequest(`/issuing/sub_account/${sub_account_id}/transactions/csv`),
+        },
+    },
+    sub_accounts: {
+        list: {
+            withCards: {
+                getSinglecards: (wallet_uuid, limit, offset) => apiClientV1.getRequest(`/issuing/sub_account/list/${wallet_uuid}`, {
+                    params: {
+                        limit,
+                        offset,
+                        lt_cards_limit: 2,
+                        gt_cards_limit: 0,
+                        show_cards: true,
+                        pagination: true,
+                    },
+                }),
+                getAll: (wallet_uuid, limit, offset) => apiClientV1.getRequest(`/issuing/sub_account/list/${wallet_uuid}`, {
+                    params: { limit, offset, show_cards: true, pagination: true },
+                }),
+            },
+            withoutCards: {
+                getAll: ({ wallet_uuid, ...params }) => apiClientV1.getRequest(`/issuing/sub_account/list/${wallet_uuid}`, {
+                    params: { ...params, pagination: true },
+                }),
+            },
+        },
+        getByUuid: (uuid) => apiClientV1.getRequest(`/issuing/sub_account/${uuid}`),
+        create: (wallet_id, program_id) => apiClientV1.postRequest(`/issuing/sub_account`, {
+            data: { wallet_id, program_id },
+        }),
+        transactions: {
+            get: ({ sub_account_id, ...params }) => apiClientV1.getRequest(`/issuing/sub_account/${sub_account_id}/transactions`, {
+                params,
+            }),
+        },
+    },
+    config: {
+        programs: {
+            getAll: (params) => apiClientV1.getRequest('/issuing/config/programs', { params }),
+        },
+    },
+};

package/dist/api/kyc.d.ts

@@ -0,0 +1,21 @@
+import { API } from './types/types';
+export declare const kyc: {
+    sumsub: {
+        generate_token: (data: API.KYC.Sumsub.GenerateToken.Request) => Promise<API.KYC.Sumsub.GenerateToken.Response>;
+    };
+    entity: {
+        get: ({ wallet_id }: API.KYC.Entity.Get.Request) => Promise<API.KYC.Entity.Get.Response>;
+    };
+    rails: {
+        info: {
+            getAll: ({ wallet_id }: API.KYC.Rails.RailInfo.List.Request) => Promise<API.KYC.Rails.RailInfo.List.Response>;
+            getSingle: ({ wallet_id, rail_id, }: API.KYC.Rails.RailInfo.SingleRail.Request) => Promise<API.KYC.Rails.RailInfo.SingleRail.Response>;
+        };
+        submit: {
+            single: ({ wallet_id, rail_id, }: API.KYC.Rails.Submit.Single.Request) => Promise<API.KYC.Rails.Submit.Single.Response>;
+        };
+        terms: {
+            confirm: ({ wallet_id, rail_id, }: API.KYC.Rails.Terms.Confirm.Request) => Promise<API.KYC.Rails.Terms.Confirm.Response>;
+        };
+    };
+};

package/dist/api/kyc.js

@@ -0,0 +1,21 @@
+import { apiClientV1, apiClientV2 } from '../utils/apiClientFactory';
+export const kyc = {
+    sumsub: {
+        generate_token: (data) => apiClientV1.postRequest('/kyc/sumsub/generate_token', { data }),
+    },
+    entity: {
+        get: ({ wallet_id }) => apiClientV2.getRequest(`/kyc/${wallet_id}/entity`),
+    },
+    rails: {
+        info: {
+            getAll: ({ wallet_id }) => apiClientV2.getRequest(`/kyc/${wallet_id}/rails`),
+            getSingle: ({ wallet_id, rail_id, }) => apiClientV2.getRequest(`/kyc/${wallet_id}/rails/${rail_id}`),
+        },
+        submit: {
+            single: ({ wallet_id, rail_id, }) => apiClientV2.postRequest(`/kyc/${wallet_id}/rails/${rail_id}`),
+        },
+        terms: {
+            confirm: ({ wallet_id, rail_id, }) => apiClientV2.postRequest(`/kyc/${wallet_id}/rails/${rail_id}/terms-and-conditions`),
+        },
+    },
+};

package/dist/api/list.d.ts

@@ -0,0 +1,16 @@
+import { AxiosRequestConfig } from 'axios';
+import { API } from './types/types';
+export declare const list: {
+    currencies: {
+        getAll: (params?: AxiosRequestConfig) => Promise<API.Currencies.CurrencyList>;
+    };
+    chains: {
+        getAll: (params?: AxiosRequestConfig) => Promise<API.Chains.ChainList>;
+    };
+    countries: {
+        getAll: (params?: AxiosRequestConfig) => Promise<API.Location.Countries.List.Response>;
+    };
+    states: {
+        getAll: ({ country_id }: API.Location.States.List.Request) => Promise<API.Location.States.List.Response>;
+    };
+};

package/dist/api/list.js

@@ -0,0 +1,16 @@
+/* eslint-disable import/prefer-default-export */
+import { apiClientV2 } from '../utils/apiClientFactory';
+export const list = {
+    currencies: {
+        getAll: (params) => apiClientV2.getRequest('/system/currencies', params),
+    },
+    chains: {
+        getAll: (params) => apiClientV2.getRequest('/system/chains', params),
+    },
+    countries: {
+        getAll: (params) => apiClientV2.getRequest('/system/countries', params),
+    },
+    states: {
+        getAll: ({ country_id }) => apiClientV2.getRequest(`/system/states/${country_id}`),
+    },
+};

package/dist/api/orders.d.ts

@@ -0,0 +1,49 @@
+import { API } from './types/types';
+export declare const orders: {
+    calc: ({ signal, ...params }: API.Orders.Calc.Request) => Promise<API.Orders.Calc.Response>;
+    orderTypes: {
+        list: () => Promise<API.Orders.OrderTypes.List.Response>;
+    };
+    create: {
+        byOrderType: {
+            TRANSFER_INTERNAL: (data: API.Orders.Create.ByOrderType.INTERNAL_TRANSFER.Request) => Promise<API.Orders.Create.ByOrderType.INTERNAL_TRANSFER.Response>;
+            WITHDRAWAL_CRYPTO: (data: API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Request) => Promise<API.Orders.Create.ByOrderType.WITHDRAWAL_CRYPTO.Response>;
+            TRANSFER_CARD_SUBACCOUNT: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Request) => Promise<API.Orders.Create.ByOrderType.TRANSFER_CARD_SUBACCOUNT.Response>;
+            TRANSFER_CARD_PREPAID: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_PREPAID.Request) => Promise<API.Orders.Create.ByOrderType.TRANSFER_CARD_PREPAID.Response>;
+            TRANSFER_CARD_WHOLESALE: (data: API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Request) => Promise<API.Orders.Create.ByOrderType.TRANSFER_CARD_WHOLESALE.Response>;
+            EXCHANGE_CRYPTO_INTERNAL: (data: API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Request) => Promise<API.Orders.Create.ByOrderType.EXCHANGE_CRYPTO_INTERNAL.Response>;
+            EXCHANGE_OMNI: (data: API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Request) => Promise<API.Orders.Create.ByOrderType.EXCHANGE_OMNI.Response>;
+            WITHDRAW_CARD_PREPAID: (data: API.Orders.Create.ByOrderType.WITHDRAW_CARD_PREPAID.Request) => Promise<API.Orders.Create.ByOrderType.WITHDRAW_CARD_PREPAID.Response>;
+            WITHDRAW_CARD_SUBACCOUNT: (data: API.Orders.Create.ByOrderType.WITHDRAW_CARD_SUBACCOUNT.Request) => Promise<API.Orders.Create.ByOrderType.WITHDRAW_CARD_SUBACCOUNT.Response>;
+        };
+    };
+    v2: {
+        calc: ({ signal, ...params }: API.Orders.V2.Calc.Request) => Promise<API.Orders.V2.Calc.Response>;
+        orderTypes: {
+            list: () => Promise<API.Orders.V2.OrderTypes.List.Response>;
+        };
+        create: {
+            byOrderType: {
+                TRANSFER_INTERNAL: (data: API.Orders.V2.Create.ByOrderType.INTERNAL_TRANSFER.Request) => Promise<API.Orders.V2.Create.ByOrderType.INTERNAL_TRANSFER.Response>;
+                HIFI_WIRE_ONRAMP: (data: API.Orders.V2.Create.ByOrderType.HIFI_WIRE_ONRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.HIFI_WIRE_ONRAMP.Response>;
+                HIFI_ACH_ONRAMP: (data: API.Orders.V2.Create.ByOrderType.HIFI_ACH_ONRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.HIFI_ACH_ONRAMP.Response>;
+                HIFI_SEPA_ONRAMP: (data: API.Orders.V2.Create.ByOrderType.HIFI_SEPA_ONRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.HIFI_SEPA_ONRAMP.Response>;
+                HIFI_WIRE_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.HIFI_WIRE_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.HIFI_WIRE_OFFRAMP.Response>;
+                HIFI_ACH_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.HIFI_ACH_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.HIFI_ACH_OFFRAMP.Response>;
+                HIFI_SEPA_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.HIFI_SEPA_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.HIFI_SEPA_OFFRAMP.Response>;
+                OMNIBUS_CRYPTO_TRANSFER: (data: API.Orders.V2.Create.ByOrderType.OMNIBUS_CRYPTO_TRANSFER.Request) => Promise<API.Orders.V2.Create.ByOrderType.OMNIBUS_CRYPTO_TRANSFER.Response>;
+                SEGREGATED_CRYPTO_TRANSFER: (data: API.Orders.V2.Create.ByOrderType.SEGREGATED_CRYPTO_TRANSFER.Request) => Promise<API.Orders.V2.Create.ByOrderType.SEGREGATED_CRYPTO_TRANSFER.Response>;
+                RN_CARDS_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.RN_CARDS_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.RN_CARDS_OFFRAMP.Response>;
+                TBD_SWIFT_WITHDRAWAL: (data: API.Orders.V2.Create.ByOrderType.TBD_SWIFT_WITHDRAWAL.Request) => Promise<API.Orders.V2.Create.ByOrderType.TBD_SWIFT_WITHDRAWAL.Response>;
+                L2F_SEPA_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.L2F_SEPA_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.L2F_SEPA_OFFRAMP.Response>;
+                L2F_SWIFT_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.L2F_SWIFT_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.L2F_SWIFT_OFFRAMP.Response>;
+                L2F_ACH_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.L2F_ACH_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.L2F_ACH_OFFRAMP.Response>;
+                L2F_WIRE_OFFRAMP: (data: API.Orders.V2.Create.ByOrderType.L2F_WIRE_OFFRAMP.Request) => Promise<API.Orders.V2.Create.ByOrderType.L2F_WIRE_OFFRAMP.Response>;
+            };
+        };
+        list: {
+            byWallet: ({ wallet_uuid, ...params }: API.Orders.V2.List.ByWallet.Request) => Promise<API.Orders.V2.List.ByWallet.Response>;
+        };
+        getById: ({ order_uuid }: API.Orders.V2.GetById.Request) => Promise<API.Orders.V2.GetById.Response>;
+    };
+};