mangopay4-nodejs-sdk 1.64.0

package/typings/models/virtualAccount.d.ts

@@ -0,0 +1,182 @@
+import { CountryISO, CurrencyISO, VirtualAccountOwner, VirtualAccountPurpose, VirtualAccountStatus } from "../types";
+import { entityBase } from "./entityBase";
+
+export namespace virtualAccount {
+
+    interface VirtualAccountData extends entityBase.EntityBaseData {
+        /**
+         * The wallet ID
+         */
+        WalletId: string;
+
+        /**
+         * The credited user ID
+         */
+        CreditedUserId: string;
+
+        /**
+         * The type of the virtual account
+         * Allowed values: `COLLECTION`, `USER_OWNED`
+         */
+        VirtualAccountPurpose: VirtualAccountPurpose;
+
+        /**
+         * The country of the IBAN. The country must correspond to the currency of the wallet
+         */
+        Country: CountryISO;
+
+        /**
+         * The status of the virtual account creation
+         */
+        Status: VirtualAccountStatus;
+
+        /**
+         * Whether the virtual account is active and can receive pay-ins. `Active` is only `true`
+         * when the `Status` is `ACTIVE`.
+         */
+        Active: boolean;
+
+        /**
+         * Owner of the virtual account.
+         */
+        AccountOwner: VirtualAccountOwner;
+
+        /**
+         * Details of the account in local account identifier format
+         */
+        LocalAccountsDetails: LocalAccountsDetails;
+
+        /**
+         * Details of the account in IBAN format.
+         * The `InternationalAccountDetails` are not returned if the country doesn’t use IBAN (e.g. AU -
+         * Australia)
+         */
+        InternationalAccountDetails: InternationalAccountDetails;
+
+        /**
+         * Information about the account’s payment capabilities
+         */
+        Capabilities: VirtualAccountCapabilities;
+
+        ResultCode: string;
+
+        ResultMessage: string;
+    }
+
+    interface CreateVirtualAccount {
+        /**
+         * The country of the IBAN. The country must correspond to the currency of the wallet
+         */
+        Country: CountryISO;
+
+        /**
+         * The type of the virtual account
+         * Allowed values: `COLLECTION`, `USER_OWNED`
+         */
+        VirtualAccountPurpose: VirtualAccountPurpose;
+
+        /**
+         * Tag
+         */
+        Tag?: string;
+    }
+
+    interface VirtualAccountAvailabilitiesData {
+        Collection: VirtualAccountAvailability[];
+        UserOwned: VirtualAccountAvailability[];
+    }
+
+    interface VirtualAccountAvailability {
+        Country: CountryISO;
+        Available: boolean;
+        Currencies: CurrencyISO[];
+    }
+
+    interface InternationalAccountDetails {
+        /**
+         * Information about the address associated with the international IBAN account.
+         */
+        Address: VirtualAccountAddress;
+
+        /**
+         * The IBAN and BIC of the account.
+         */
+        Account: InternationalAccount;
+
+        BankName: string;
+    }
+
+    interface LocalAccountsDetails {
+        /**
+         * Information about the address associated with the local IBAN account.
+         */
+        Address: VirtualAccountAddress;
+
+        Account: LocalAccount;
+
+        BankName: string;
+    }
+
+    interface VirtualAccountAddress {
+        StreetName: string;
+        PostCode: string;
+        TownName: string;
+        CountrySubDivision: string;
+        Country: CountryISO;
+    }
+
+    interface LocalAccount {
+        /**
+         * The account number of the account
+         */
+        AccountNumber: string;
+
+        /**
+         * The sort code of the account.
+         */
+        SortCode: string;
+
+        Iban: string;
+
+        Bic: string;
+
+        AchNumber: string;
+
+        FedWireNumber: string;
+
+        AccountType: string;
+
+        BranchCode: string;
+
+        InstitutionNumber: string;
+    }
+
+    interface InternationalAccount {
+        /**
+         * IBAN
+         */
+        Iban: string;
+
+        /**
+         * BIC
+         */
+        Bic: string;
+    }
+
+    interface VirtualAccountCapabilities {
+        /**
+         * Whether or not local bank wires can be made to this account.
+         */
+        LocalPayinAvailable: boolean;
+
+        /**
+         * Whether or not international bank wires can be made to this account
+         */
+        InternationalPayinAvailable: boolean;
+
+        /**
+         * List of currencies supported by the account
+         */
+        Currencies: CurrencyISO[];
+    }
+}

package/typings/models/wallet.d.ts

@@ -0,0 +1,46 @@
+import { CurrencyISO, Omit, PickPartial } from "../types";
+import { entityBase } from "./entityBase";
+import { money } from "./money";
+
+export namespace wallet {
+    import MoneyData = money.MoneyData;
+
+    type ClientFundsType = "FEES" | "CREDIT";
+
+    type FundsType = "DEFAULT" | ClientFundsType;
+
+    type CreateWallet = UpdateWallet & Pick<WalletData, "Owners" | "Currency" | "Description">;
+
+    type UpdateWallet = PickPartial<WalletData, "Tag" | "Description">;
+
+    interface WalletData extends entityBase.EntityBaseData {
+        /**
+         * An array of userIDs of who own's the wallet. For now, you only can set up a unique owner.
+         */
+        Owners: [string];
+
+        /**
+         * The current balance of the wallet
+         */
+        Balance: MoneyData;
+
+        /**
+         * The type of funds in the wallet
+         */
+        FundsType: FundsType;
+
+        /**
+         * A description of the wallet
+         */
+        Description: string;
+
+        /**
+         * The currency - should be ISO_4217 format
+         */
+        Currency: CurrencyISO;
+    }
+
+    interface ClientWalletData extends Omit<WalletData, "Owners" | "Description"> {
+        FundsType: ClientFundsType;
+    }
+}

package/typings/models.d.ts

@@ -0,0 +1,74 @@
+import { MakeKeysRequired } from "./types";
+import { wallet } from "./models/wallet";
+import { user } from "./models/user";
+import { address } from "./models/address";
+import { base } from "./base";
+import MangoPay = require("./index");
+
+export namespace Models {
+    import EntityBase = MangoPay.models.EntityBase;
+    import ModelMethods = MangoPay.models.ModelMethods;
+    import DependsObject = base.DependsObject;
+
+    class Model<T extends {} = any> implements ModelMethods<T> {
+        initialize(): void;
+
+        getData<K extends keyof T>(attribute: K): T[K];
+
+        setData<K extends keyof T>(attribute: K, value: T[K]): this;
+
+        setData(attribute: Partial<T>): this;
+
+        setData(attribute: any, value?: any): this;
+
+        getReadOnlyProperties(): Array<keyof T>;
+
+        getDependsObjects(): DependsObject[];
+
+        parse(): void;
+
+        constructor(data: T);
+    }
+
+    class Address extends EntityBase<address.AddressData> {
+        constructor(data: Partial<address.AddressData> | address.CreateAddress);
+    }
+
+    class BankAccountDetails {
+        constructor(data: any);
+    }
+
+    class Wallet extends EntityBase<wallet.WalletData> {
+        constructor(data: wallet.CreateWallet | wallet.UpdateWallet);
+    }
+
+    class UserLegal extends EntityBase<user.UserLegalData> {
+        PersonType: "LEGAL";
+
+        constructor(
+            data: MakeKeysRequired<Partial<user.UserLegalData>,
+                user.RequiredUserLegalData>
+        );
+
+        /**
+         * Sets the person type for the model
+         * @param personType
+         */
+        setPersonType(type: user.PersonType): void;
+    }
+
+    class UserNatural extends EntityBase<user.UserNaturalData> {
+        PersonType: "NATURAL";
+
+        constructor(
+            data: MakeKeysRequired<Partial<user.UserNaturalData>,
+                user.RequiredUserNaturalData>
+        );
+
+        /**
+         * Sets the person type for the model
+         * @param personType
+         */
+        setPersonType(type: user.PersonType): void;
+    }
+}

package/typings/services/BankAccounts.d.ts

@@ -0,0 +1,12 @@
+import { transaction } from "../models/transaction";
+import { base } from "../base";
+import MethodOverload = base.MethodOverload;
+
+export class BankAccounts {
+    /**
+     * Retrieve list of transactions for a bank account
+     * @param bankAccountId
+     * @param options
+     */
+    getTransactions: MethodOverload<string, transaction.TransactionData[]>;
+}

package/typings/services/BankingAliases.d.ts

@@ -0,0 +1,51 @@
+import { bankingAlias } from "../models/bankingAlias";
+import { Omit } from "../types";
+import { base } from "../base";
+import MethodOverload = base.MethodOverload;
+import NoArgMethodOverload = base.NoArgMethodOverload;
+
+export class BankingAliases {
+    /**
+     * Create a banking alias
+     * @param bankingAlias
+     * @param options
+     */
+    create: MethodOverload<bankingAlias.CreateIBANBankingAlias,
+        bankingAlias.IBANBankingAliasData>;
+
+    /**
+     * Get a banking alias
+     * @param bankingAliasId
+     * @param options
+     */
+    get: MethodOverload<string, bankingAlias.IBANBankingAliasData>;
+
+    /**
+     * Get all banking aliases
+     * @param walletId
+     * @param options
+     */
+    getAll: MethodOverload<string, bankingAlias.IBANBankingAliasData[]>;
+
+    /**
+     * Update banking alias
+     * @param bankingAliasId
+     * @param options
+     */
+    update: MethodOverload<bankingAlias.UpdateIBANBankingAlias,
+        bankingAlias.IBANBankingAliasData>;
+
+    /**
+     * Deactivate banking alias
+     * @param bankingAliasId
+     * @param options
+     */
+    deactivate: MethodOverload<string, bankingAlias.IBANBankingAliasData>;
+
+    /**
+     * Activate banking alias
+     * @param bankingAliasId
+     * @param options
+     */
+    activate: MethodOverload<string, bankingAlias.IBANBankingAliasData>;
+}

package/typings/services/CardPreauthorizations.d.ts

@@ -0,0 +1,44 @@
+import { cardPreAuthorization } from "../models/cardPreauthorization";
+import { base } from "../base";
+import MethodOverload = base.MethodOverload;
+
+/**
+ * The PreAuthorization Object ensures the solvency of a registered card for 7 days. The overall process is as follows:
+ *
+ * 1. Register a card (CardRegistration)
+ * 2. Create a PreAuthorization with the CardId. This allows you to charge an amount on a card
+ * 3. Charge the card through the PreAuthorized PayIn object (Payins/preauthorized/direct)
+ *
+ * How does PreAuthorization work?
+ * - Once the PreAuthorization object is created the Status is "CREATED" until 3D secure validation.
+ * - If the authorization is successful the status is "SUCCEEDED" if it failed the status is "FAILED".
+ * - Once Status = "SUCCEEDED" and PaymentStatus = "WAITING" you can charge the card.
+ * - The Pay-In amount has to be less than or equal to the amount authorized.
+ */
+export class CardPreAuthorizations {
+    /**
+     * Create new pre-authorization
+     * @param cardPreAuthorization
+     * @param options
+     */
+    create: MethodOverload<
+        cardPreAuthorization.CreateCardPreAuthorization,
+        cardPreAuthorization.CardPreAuthorizationData
+        >;
+
+    /**
+     * Get data for Card pre-authorization
+     * @param cardPreAuthorizationId
+     * @param options
+     */
+    get: MethodOverload<string, cardPreAuthorization.CardPreAuthorizationData>;
+
+    /**
+     * Update pre-authorization object (currently only supports cancellation)
+     * @param  cardPreAuthorization
+     */
+    update: MethodOverload<
+        cardPreAuthorization.UpdateCardPreAuthorization,
+        cardPreAuthorization.CardPreAuthorizationData
+        >;
+}

package/typings/services/CardRegistrations.d.ts

@@ -0,0 +1,43 @@
+import { cardRegistration } from "../models/cardRegistration";
+import { base } from "../base";
+import MethodOverload = base.MethodOverload;
+
+/**
+ * You need to register a card in order to process a Direct PayIn. Card registration enables you to tokenize a Card. These are the steps to follow:
+ *
+ * 1. Create a CardRegistration Object
+ * 2. Get a PreRegistrationData
+ * 3. The user posts PreRegistrationData, AccessKey and card details through a form (PHP & JS samples) to the CardRegistrationURL (5. in the diagram)
+ * 4. Get a RegistrationData back
+ * 5. Edit the CardRegistration Object (POST method) with the RegistrationData just received
+ * 6. Get the CardId ready to use into the Direct PayIn Object
+ *
+ * - If you don’t want to save the card you must change the field ACTIVE in the card object to false
+ */
+export class CardRegistrations {
+    /**
+     * Create new card registration
+     * @param cardRegistration
+     * @param options
+     */
+    create: MethodOverload<
+        cardRegistration.CreateCardRegistration,
+        cardRegistration.CardRegistrationData
+        >;
+
+    /**
+     * View a card registration
+     * @param cardRegistrationId
+     * @param options
+     */
+    get: MethodOverload<string, cardRegistration.CardRegistrationData>;
+
+    /**
+     * Update card registration
+     * @param  cardRegistration
+     */
+    update: MethodOverload<
+        cardRegistration.UpdateCardRegistration,
+        cardRegistration.CardRegistrationData
+        >;
+}

package/typings/services/Cards.d.ts

@@ -0,0 +1,80 @@
+import { card } from "../models/card";
+import { transaction } from "../models/transaction";
+import { cardPreAuthorization } from "../models/cardPreauthorization";
+import { base } from "../base";
+import { cardValidation } from "../models/cardValidation";
+import MethodOverload = base.MethodOverload;
+import TwoArgsMethodOverload = base.TwoArgsMethodOverload;
+
+export class Cards {
+    /**
+     * Get card
+     * @param cardId
+     * @param ptions
+     */
+    get: MethodOverload<string, card.CardData>;
+
+    /**
+     * Gets a list of cards having the same fingerprint.
+     * The fingerprint is a hash uniquely generated per 16-digit card number.
+     *
+     * @param fingerprint The fingerprint hash
+     */
+    getByFingerprint: MethodOverload<string, card.CardData[]>;
+
+    /**
+     * Update card (currently only supports deactivation)
+     * @param card
+     * @param options
+     */
+    update: MethodOverload<card.UpdateCard, card.CardData>;
+
+    /**
+     * Get list of Transactions of a Card
+     * @param cardId
+     * @param options
+     */
+    getTransactions: MethodOverload<string, transaction.TransactionData[]>;
+
+    /**
+     * Gets list of PreAuthorizations of a Card.
+     * @param cardId
+     * @param options
+     */
+    getPreAuthorizations: MethodOverload<string,
+        cardPreAuthorization.CardPreAuthorizationData[]>;
+
+    /**
+     * Validate a card
+     * @param cardId
+     * @param cardValidation
+     * @param callback
+     * @param options
+     * @returns {*|Promise}
+     */
+    validate: TwoArgsMethodOverload<
+        string,
+        cardValidation.CreateCardValidation,
+        cardValidation.CardValidationData
+    >;
+
+    /**
+     * Validate a card
+     * @param cardId
+     * @param cardValidationId
+     * @param callback
+     * @param options
+     * @returns {*|Promise}
+     */
+    getCardValidation: TwoArgsMethodOverload<
+        string,
+        string,
+        cardValidation.CardValidationData
+    >;
+
+    /**
+     * Get a list of Transactions for a fingerprint
+     * @param fingerprint
+     */
+    getTransactionsForFingerprint: MethodOverload<string, transaction.TransactionData[]>;
+}

package/typings/services/Clients.d.ts

@@ -0,0 +1,77 @@
+import { client } from "../models/client";
+import { wallet } from "../models/wallet";
+import { CurrencyISO } from "../types";
+import { transaction } from "../models/transaction";
+import { base } from "../base";
+import { payIn } from "../models/payIn";
+import NoArgMethodOverload = base.NoArgMethodOverload;
+import MethodOverload = base.MethodOverload;
+import TwoArgsMethodOverload = base.TwoArgsMethodOverload;
+
+export class Clients {
+    /**
+     * Get the client
+     */
+    get: NoArgMethodOverload<client.ClientData>;
+
+    /**
+     * Update the client
+     * @param client
+     * @param options
+     */
+    update: MethodOverload<client.UpdateClient, client.ClientData>;
+
+    /**
+     * Upload client logo from base64 image string
+     * @param base64Logo
+     * @param options
+     */
+    uploadLogo: MethodOverload<string, client.ClientData>;
+
+    /**
+     * Upload client logo from file path
+     * @param filePath
+     * @param options
+     */
+    uploadLogoFromFile: MethodOverload<string, client.ClientData>;
+
+    /**
+     * Get all client wallets
+     * @param options
+     */
+    getClientWallets: NoArgMethodOverload<wallet.ClientWalletData[]>;
+
+    /**
+     * Get a client wallet
+     * @param fundsType
+     * @param currency
+     * @param options
+     */
+    getClientWallet: TwoArgsMethodOverload<wallet.ClientFundsType,
+        CurrencyISO,
+        wallet.ClientWalletData>;
+
+    /**
+     * Get client wallets by the type of funds
+     * @param fundsType
+     * @param options
+     */
+    getClientWalletsByFundsType: MethodOverload<wallet.ClientFundsType,
+        wallet.ClientWalletData[]>;
+
+    /**
+     * Get a client wallet's transactions
+     * @param fundsType
+     * @param currency
+     * @param options
+     */
+    getClientWalletTransactions: TwoArgsMethodOverload<wallet.ClientFundsType,
+        CurrencyISO,
+        transaction.TransactionData[]>;
+
+    /**
+     * Create a Direct Bank Wire PayIn, instead of a Settlement Transfer, to the Repudiation Wallet in order to settle the negative balance due to a LOST dispute.
+     * The object expires 1 month after creation if no funds are received.
+     */
+    createBankWireDirectPayIn: MethodOverload<client.CreateBankWireDirectPayIn, payIn.BankWireDirectPayInData>
+}

package/typings/services/Conversions.d.ts

@@ -0,0 +1,23 @@
+import { base } from "../base";
+import { conversionRate } from "../models/conversionRate";
+import { conversion } from "../models/conversion";
+import MethodOverload = base.MethodOverload;
+import TwoArgsMethodOverload = base.TwoArgsMethodOverload;
+
+export class Conversions {
+    getConversionRate: TwoArgsMethodOverload<string, string, conversionRate.ConversionRateData>;
+
+    createInstantConversion: MethodOverload<conversion.CreateInstantConversion, conversion.ConversionData>;
+
+    createQuotedConversion: MethodOverload<conversion.CreateQuotedConversion, conversion.ConversionData>;
+
+    createClientWalletsQuotedConversion: MethodOverload<conversion.CreateClientWalletsQuotedConversion, conversion.ConversionData>;
+
+    createClientWalletsInstantConversion: MethodOverload<conversion.CreateClientWalletsInstantConversion, conversion.ConversionData>;
+
+    getConversion: MethodOverload<string, conversion.ConversionData>;
+
+    createQuote: MethodOverload<conversion.CreateQuote, conversion.QuoteData>;
+
+    getQuote: MethodOverload<string, conversion.QuoteData>;
+}

package/typings/services/Deposits.d.ts

@@ -0,0 +1,20 @@
+import { base } from "../base";
+import { deposit } from "../models/deposit";
+import { transaction } from "../models/transaction";
+import MethodOverload = base.MethodOverload;
+
+export class Deposits {
+    create: MethodOverload<deposit.CreateDeposit, deposit.DepositData>;
+
+    get: MethodOverload<string, deposit.DepositData>;
+
+    cancel: MethodOverload<string, deposit.DepositData>;
+
+    getAllForCard: MethodOverload<string, deposit.DepositData[]>;
+
+    getAllForUser: MethodOverload<string, deposit.DepositData[]>;
+
+    update: MethodOverload<deposit.UpdateDeposit, deposit.DepositData>;
+
+    getTransactions: MethodOverload<string, transaction.TransactionData[]>;
+}

package/typings/services/DisputeDocuments.d.ts

@@ -0,0 +1,27 @@
+import { disputeDocument } from "../models/disputeDocument";
+import { base } from "../base";
+import NoArgMethodOverload = base.NoArgMethodOverload;
+import MethodOverload = base.MethodOverload;
+
+export class DisputeDocuments {
+    /**
+     * Get all KycDocuments
+     * @param options
+     */
+    getAll: NoArgMethodOverload<disputeDocument.DisputeDocumentData[]>;
+
+    /**
+     * Get KycDocument
+     * @param documentId
+     * @param options
+     */
+    get: MethodOverload<string, disputeDocument.DisputeDocumentData>;
+
+    /**
+     * Creates temporary URLs where each page of a KYC document can be viewed.
+     * @param documentId
+     */
+    createDisputeDocumentConsult: MethodOverload<string,
+        any // Unsure of data structure from docs
+        >;
+}