@spreeloop/orange_money 1.0.0

package/src/payments/operations/get_payment_status.spec.ts

@@ -0,0 +1,82 @@
+import * as requests from '../../utils/https';
+import { OrangeMoneyPaymentStatus } from '../utils/constants';
+
+import { TargetEnvironment } from '../../utils/utils';
+import { GetOrangeMoneyPaymentRequest } from '../utils/request_model';
+import { getPaymentStatus } from './get_payment_status';
+
+const logger = console;
+describe('Test the status verification', () => {
+  const mobilePaymentParamForCheckStatus: GetOrangeMoneyPaymentRequest = {
+    accessToken: '1e23bee1-37dc-3015-a7d6-cb70e566bd64',
+    payToken: 'MP220807558VEF7A9C4F09AED',
+  };
+  it('Return the payment status', async () => {
+    jest.spyOn(requests, 'getRequest').mockResolvedValue({
+      response: {
+        status: 200,
+        data: {
+          message: 'Transaction retrieved successfully',
+          data: {
+            id: 74581010,
+            createtime: '1682001669',
+            subscriberMsisdn: '655637944',
+            amount: 1100,
+            payToken: 'MP23042031A1724A914DF0382D01',
+            txnid: 'MP230420.1541.C39196',
+            txnmode: 'zSapffVPWccheVZQRtvG',
+            inittxnmessage:
+              'Paiement e la clientele done.The devrez confirmer le paiement en saisissant son code PIN et vous recevrez alors un SMS. Merci dutiliser des services Orange Money.',
+            inittxnstatus: '200',
+            confirmtxnstatus: '200',
+            confirmtxnmessage:
+              'Paiement de SPREELOOP reussi par 655637944 PEKE. ID transaction:MP230420.1541.C39196, Montant:1100 FCFA. Solde: 55.81 FCFA.',
+            status: 'SUCCESSFULL',
+            notifUrl:
+              'https://europe-west1-place-prod.cloudfunctions.net/api-1/payment/orange_money/live/zSapffVPWccheVZQRtvG',
+            description: 'Commande',
+            channelUserMsisdn: '696431937',
+          },
+        },
+      },
+    });
+    const result = await getPaymentStatus({
+      mobileStatusVerificationParams: mobilePaymentParamForCheckStatus,
+      paymentServiceConfig: {
+        targetEnvironment: TargetEnvironment.fake,
+        xAuthToken: 'ABCDEGHIJKLMNOPQRSTUVW',
+        apiUserName: 'secret',
+        apiPassword: 'secret',
+        logger: logger,
+      },
+      endPoint: 'https://api.paytoken.co',
+    });
+    expect(result.data?.status).toBe(
+      OrangeMoneyPaymentStatus.SUCCESSFULL_MOBILE_PAYMENT
+    );
+  });
+  it('Return the error response', async () => {
+    jest.spyOn(requests, 'getRequest').mockResolvedValue({
+      error: {
+        responseError: {
+          data: [Object],
+          status: 401,
+          statusText: 'Unauthorized',
+          headers: null,
+        },
+      },
+    });
+    const result = await getPaymentStatus({
+      mobileStatusVerificationParams: mobilePaymentParamForCheckStatus,
+      paymentServiceConfig: {
+        targetEnvironment: TargetEnvironment.fake,
+        xAuthToken: 'ABCDEGHIJKLMNOPQRSTUVW',
+        apiUserName: 'secret',
+        apiPassword: 'secret',
+        logger: logger,
+      },
+      endPoint: 'https://api.paytoken.co',
+    });
+    expect(result.error).toBeDefined();
+  });
+});

package/src/payments/operations/get_payment_status.ts

@@ -0,0 +1,78 @@
+import { getRequest, isSuccessfulCodeResponse } from '../../utils/https';
+import { ApiErrorType, ApiKey, ConstantRequestField } from '../utils/constants';
+import {
+  GenericRequestResponseData,
+  OrangeMoneyPaymentParams,
+} from '../utils/joi_schema';
+import {
+  GetOrangeMoneyPaymentRequest,
+  GetOrangeMoneyPaymentResponse,
+} from '../utils/request_model';
+
+/**
+ * Gets the mobile payment status.
+ *
+ * @param {Object} options - The options object.
+ * @param {GetOrangeMoneyPaymentRequest} options.mobileStatusVerificationParams - The parameters for mobile status verification.
+ * @param {string} endPoint - The init payment end point.
+ * @param {OrangeMoneyPaymentParams} paymentServiceConfig - The mobile payment config parameters.
+ *    - {TargetEnvironment} PaymentServiceConfig.targetEnvironment - The target environment.
+ *    - {string} PaymentServiceConfig.apiUserName - The api user name.
+ *    - {string} PaymentServiceConfig.xAuthToken - The x-auth-token.
+ *    - {string} PaymentServiceConfig.apiPassword - The api password.
+ *    - {string} [PaymentServiceConfig.orangeMoneyVersion] - The orange money version.
+ *    - {LoggerInterface} PaymentServiceConfig.logger - The logger interface.
+ * @return {Promise<GetOrangeMoneyPaymentResponse>} The promise that resolves to the mobile payment check status response.
+ */
+export async function getPaymentStatus({
+  mobileStatusVerificationParams,
+  paymentServiceConfig,
+  endPoint,
+}: {
+  mobileStatusVerificationParams: GetOrangeMoneyPaymentRequest;
+  paymentServiceConfig: OrangeMoneyPaymentParams;
+  endPoint: string;
+}): Promise<GetOrangeMoneyPaymentResponse> {
+  const logger = paymentServiceConfig.logger;
+
+  const headers = {
+    [ApiKey.keyAuthorization]: `Bearer ${mobileStatusVerificationParams.accessToken}`,
+    [ApiKey.keyContentType]: ConstantRequestField.typeJson,
+    [ApiKey.keyXAuthToken]: paymentServiceConfig.xAuthToken,
+  };
+
+  logger.info(
+    `[ORANGE MONEY] Checks the ORANGE MONEY Payment status with route: ${endPoint}`
+  );
+
+  const response = await getRequest<GenericRequestResponseData>({
+    headers: headers,
+    route: endPoint,
+    logger: logger,
+  });
+  const responseData = response?.response;
+
+  if (responseData && isSuccessfulCodeResponse(responseData.status)) {
+    logger.log(
+      `[ORANGE MONEY] Status verification successful with result ${JSON.stringify(
+        responseData.data
+      )}`
+    );
+    return {
+      data: {
+        status: responseData.data.data.status,
+      },
+      raw: responseData.data,
+    };
+  }
+
+  logger.warn(
+    `[ORANGE MONEY] Status verification failed with error data: ${JSON.stringify(
+      response.error
+    )}`
+  );
+  return {
+    raw: response.error,
+    error: ApiErrorType.failedToCheckPaymentStatus,
+  };
+}

package/src/payments/operations/initialize_om_payment.spec.ts

@@ -0,0 +1,234 @@
+import * as requests from '../../utils/https';
+import { ApiErrorType } from '../utils/constants';
+
+import { TargetEnvironment } from '../../utils/utils';
+import { InitializeOrangeMoneyRequest } from '../utils/request_model';
+import { initializeOmPayment } from './initialize_om_payment';
+
+const logger = console;
+
+describe('Test the initialization of payment', () => {
+  const mobileInitiateParams: InitializeOrangeMoneyRequest = {
+    amount: 100,
+    notifUrl: 'https://localhost',
+    transactionId: '1',
+    pinCode: '123',
+    channelUserNumber: '698526541',
+    subscriberNumber: '698526541',
+    accessToken: '1e23bee1-37dc-3015-a7d6-cb70e566bd64',
+    payToken: 'MP220807558VEF7A9C4F09AED',
+  };
+
+  it('Initialization failed cause of invalid channel number', async () => {
+    jest.spyOn(requests, 'postRequest').mockImplementationOnce(() =>
+      Promise.resolve({
+        response: {
+          status: 417,
+          data: {
+            message: '60019 :: Le solde du compte du payeur est insuffisant',
+            data: {
+              id: 75742131,
+              createtime: '1682612128',
+              subscriberMsisdn: '696689073',
+              amount: 90,
+              payToken: 'MP2304270429730CE5AC78D276A6',
+              txnid: null,
+              txnmode: '84d1uhuhiuhiliubi',
+              inittxnmessage: 'Le solde du compte du payeur est insuffisant',
+              inittxnstatus: '60019',
+              confirmtxnstatus: null,
+              confirmtxnmessage: null,
+              status: 'FAILED',
+              notifUrl: '',
+              description: '',
+              channelUserMsisdn: '696431937',
+            },
+          },
+        },
+      })
+    );
+    const result = await initializeOmPayment({
+      mobileInitParams: {
+        transactionId: mobileInitiateParams.transactionId,
+        amount: mobileInitiateParams.amount,
+        subscriberNumber: mobileInitiateParams.subscriberNumber,
+        notifUrl: mobileInitiateParams.notifUrl,
+        description: mobileInitiateParams.description,
+        pinCode: mobileInitiateParams.pinCode,
+        channelUserNumber: '688526541',
+        payToken: mobileInitiateParams.payToken,
+        accessToken: mobileInitiateParams.accessToken,
+      },
+      paymentConfig: {
+        orangeMoneyVersion: '1.2.0',
+        apiPassword: 'secret',
+        apiUserName: 'secret',
+        xAuthToken: 'ABCDEGHIJKLMNOPQRSTUVW',
+        targetEnvironment: TargetEnvironment.fake,
+        logger: logger,
+      },
+      endPoint: 'https://api.paytoken.co',
+    });
+    expect(result.error).toEqual(ApiErrorType.failedToInitiateThePayment);
+  });
+  it('Initialization failed cause of insufficient balance', async () => {
+    jest.spyOn(requests, 'postRequest').mockImplementationOnce(() =>
+      Promise.resolve({
+        response: {
+          status: 417,
+          data: {
+            message: '60019 :: Le solde du compte du payeur est insuffisant',
+            data: {
+              id: 75742131,
+              createtime: '1682612128',
+              subscriberMsisdn: '696689073',
+              amount: 90,
+              payToken: 'MP2304270429730CE5AC78D276A6',
+              txnid: null,
+              txnmode: '84d1uhuhiuhiliubi',
+              inittxnmessage: 'Le solde du compte du payeur est insuffisant',
+              inittxnstatus: '60019',
+              confirmtxnstatus: null,
+              confirmtxnmessage: null,
+              status: 'FAILED',
+              notifUrl: '',
+              description: '',
+              channelUserMsisdn: '696431937',
+            },
+          },
+        },
+      })
+    );
+    const result = await initializeOmPayment({
+      mobileInitParams: {
+        transactionId: mobileInitiateParams.transactionId,
+        amount: mobileInitiateParams.amount,
+        subscriberNumber: mobileInitiateParams.subscriberNumber,
+        notifUrl: mobileInitiateParams.notifUrl,
+        description: mobileInitiateParams.description,
+        pinCode: mobileInitiateParams.pinCode,
+        channelUserNumber: mobileInitiateParams.channelUserNumber,
+        payToken: mobileInitiateParams.payToken,
+        accessToken: mobileInitiateParams.accessToken,
+      },
+      paymentConfig: {
+        orangeMoneyVersion: '1.2.0',
+        apiPassword: 'secret',
+        apiUserName: 'secret',
+        xAuthToken: 'ABCDEGHIJKLMNOPQRSTUVW',
+        targetEnvironment: TargetEnvironment.fake,
+        logger: logger,
+      },
+      endPoint: 'https://api.paytoken.co',
+    });
+    expect(result.error).toEqual(ApiErrorType.insufficientFunds);
+  });
+  it('Initialization failed cause of account blocked ', async () => {
+    jest.spyOn(requests, 'postRequest').mockImplementationOnce(() =>
+      Promise.resolve({
+        response: {
+          status: 417,
+          data: {
+            message: '60019 :: Utilisateur bloque',
+            data: {
+              id: 75742131,
+              createtime: '1682612128',
+              subscriberMsisdn: '237696689073',
+              amount: 90,
+              payToken: 'MP2304270429730CE5AC78D276A6',
+              txnid: null,
+              txnmode: '84d1uhuhiuhiliubi',
+              inittxnmessage: 'Utilisateur bloque',
+              inittxnstatus: '60019',
+              confirmtxnstatus: null,
+              confirmtxnmessage: null,
+              status: 'FAILED',
+              notifUrl: '',
+              description: '',
+              channelUserMsisdn: '696431937',
+            },
+          },
+        },
+      })
+    );
+    const result = await initializeOmPayment({
+      mobileInitParams: {
+        transactionId: mobileInitiateParams.transactionId,
+        amount: mobileInitiateParams.amount,
+        subscriberNumber: mobileInitiateParams.subscriberNumber,
+        notifUrl: mobileInitiateParams.notifUrl,
+        description: mobileInitiateParams.description,
+        pinCode: mobileInitiateParams.pinCode,
+        channelUserNumber: mobileInitiateParams.channelUserNumber,
+        payToken: mobileInitiateParams.payToken,
+        accessToken: mobileInitiateParams.accessToken,
+      },
+      paymentConfig: {
+        orangeMoneyVersion: '1.2.0',
+        apiPassword: 'secret',
+        apiUserName: 'secret',
+        xAuthToken: 'ABCDEGHIJKLMNOPQRSTUVW',
+        targetEnvironment: TargetEnvironment.fake,
+        logger: logger,
+      },
+      endPoint: 'https://api.paytoken.co',
+    });
+    expect(result.error).toEqual(ApiErrorType.accountLocked);
+  });
+
+  it('Initialization Successful', async () => {
+    jest.spyOn(requests, 'postRequest').mockImplementationOnce(() =>
+      Promise.resolve({
+        response: {
+          status: 200,
+          data: {
+            message: 'Payment request successfully initiated',
+            data: {
+              id: 75742131,
+              createtime: '1682612128',
+              subscriberMsisdn: '237696689073',
+              amount: 90,
+              payToken: 'MP2304270429730CE5AC78D276A6',
+              txnid: null,
+              txnmode: '84d1uhuhiuhiliubi',
+              inittxnmessage:
+                'Vous avez saisi un montant superieur au montant maximum autorise',
+              inittxnstatus: '60019',
+              confirmtxnstatus: null,
+              confirmtxnmessage: null,
+              status: 'PENDING',
+              notifUrl: '',
+              description: '',
+              channelUserMsisdn: '696431937',
+            },
+          },
+        },
+      })
+    );
+    const result = await initializeOmPayment({
+      mobileInitParams: {
+        transactionId: mobileInitiateParams.transactionId,
+        amount: mobileInitiateParams.amount,
+        subscriberNumber: mobileInitiateParams.subscriberNumber,
+        notifUrl: mobileInitiateParams.notifUrl,
+        description: mobileInitiateParams.description,
+        pinCode: mobileInitiateParams.pinCode,
+        channelUserNumber: mobileInitiateParams.channelUserNumber,
+        payToken: mobileInitiateParams.payToken,
+        accessToken: mobileInitiateParams.accessToken,
+      },
+      paymentConfig: {
+        orangeMoneyVersion: '1.2.0',
+        apiPassword: 'secret',
+        apiUserName: 'secret',
+        xAuthToken: 'ABCDEGHIJKLMNOPQRSTUVW',
+        targetEnvironment: TargetEnvironment.fake,
+        logger: logger,
+      },
+      endPoint: 'https://api.paytoken.co',
+    });
+    expect(result.data).toStrictEqual({
+      payToken: 'MP220807558VEF7A9C4F09AED',
+    });
+  });
+});

package/src/payments/operations/initialize_om_payment.ts

@@ -0,0 +1,191 @@
+import {
+  RequestResponse,
+  RequestStatusCode,
+  isSuccessfulCodeResponse,
+  postRequest,
+} from '../../utils/https';
+import { Routes } from '../routes/routes';
+import {
+  ApiErrorType,
+  ApiKey,
+  ConstantRequestField,
+  OrangeMoneyErrorMessage,
+} from '../utils/constants';
+import {
+  GenericRequestResponseData,
+  InitPaymentBodySchema,
+  OrangeMoneyPaymentParams,
+  initPaymentBodySchema,
+} from '../utils/joi_schema';
+import {
+  InitializeOrangeMoneyRequest,
+  InitializeOrangeMoneyResponse,
+} from '../utils/request_model';
+import { validateData } from '../utils/utils';
+
+/**
+ * Initiates the payment.
+ *
+ * @param {InitializeOmPaymentRequest} mobileInitParams - The mobile initialization parameters.
+ * @param {string} endPoint - The init payment end point.
+ * @param {OrangeMoneyPaymentParams} paymentConfig - The mobile payment config parameters.
+ *    - {TargetEnvironment} paymentConfig.targetEnvironment - The target environment.
+ *    - {string} paymentConfig.apiUserName - The api user name.
+ *    - {string} paymentConfig.xAuthToken - The x-auth-token.
+ *    - {string} paymentConfig.apiPassword - The api password.
+ *    - {string} [paymentConfig.orangeMoneyVersion] - The orange money version.
+ *    - {LoggerInterface} paymentConfig.logger - The logger interface.
+ * @return {Promise<InitializeOrangeMoneyResponse>} The promise that resolves to the mobile payment initialization response.
+ */
+export async function initializeOmPayment({
+  mobileInitParams,
+  paymentConfig,
+  endPoint,
+}: {
+  mobileInitParams: InitializeOrangeMoneyRequest;
+  paymentConfig: OrangeMoneyPaymentParams;
+  endPoint: string;
+}): Promise<InitializeOrangeMoneyResponse> {
+  const logger = paymentConfig.logger;
+
+  const paymentParams = {
+    mobileInitParams: mobileInitParams,
+    paymentConfig: paymentConfig,
+    endPoint: endPoint,
+  };
+
+  const response = await initializeOmPaymentInternal(paymentParams);
+
+  if (response.schemaErrorMessage) {
+    logger.warn(
+      `[ORANGE MONEY] Initialization failed with error data: ${JSON.stringify(
+        response.schemaErrorMessage
+      )}`
+    );
+    return {
+      raw: response.schemaErrorMessage,
+      error: ApiErrorType.failedToInitiateThePayment,
+    };
+  }
+
+  const requestResponse = response.requestResult?.response;
+
+  if (requestResponse && isSuccessfulCodeResponse(requestResponse.status)) {
+    logger.info(
+      `[ORANGE MONEY] Initialization successful with result ${JSON.stringify(
+        requestResponse.data
+      )}`
+    );
+    return {
+      data: {
+        payToken: mobileInitParams.payToken,
+      },
+      raw: requestResponse.data,
+    };
+  }
+  if (
+    requestResponse &&
+    requestResponse.status === RequestStatusCode.expectationFailed
+  ) {
+    const errorData = requestResponse.data.data;
+
+    logger.warn(
+      `[ORANGE MONEY] Initialization failed failed. Raison: ${errorData.inittxnmessage}`
+    );
+    return {
+      raw: requestResponse.data,
+      error: getApiErrorMessage(errorData.inittxnmessage),
+    };
+  }
+
+  logger.warn(
+    `[ORANGE MONEY] Initialization failed with error data: ${JSON.stringify(
+      response.requestResult?.error
+    )}`
+  );
+
+  return {
+    error: ApiErrorType.failedToInitiateThePayment,
+    raw: response.requestResult?.error,
+  };
+}
+
+/**
+ * Makes a payment request using the provided parameters.
+ *
+ * @param {Object} params - An object containing the following parameters:
+ *   - {MobileInitPaymentParams} mobileInitParams: The mobile initialization parameters.
+ *   - {PaymentConfig} paymentConfig - The mobile payment config parameters.
+ *   - {string} endPoint: The init payment end point.
+ * @return {Promise} A promise that resolves to the payment request response.
+ */
+const initializeOmPaymentInternal = async (params: {
+  mobileInitParams: InitializeOrangeMoneyRequest;
+  paymentConfig: OrangeMoneyPaymentParams;
+  endPoint: string;
+}): Promise<{
+  requestResult?: RequestResponse<GenericRequestResponseData>;
+  schemaErrorMessage?: string;
+}> => {
+  const routes = new Routes(params.paymentConfig.orangeMoneyVersion);
+  const headers = {
+    [ApiKey.keyAuthorization]: `Bearer ${params.mobileInitParams.accessToken}`,
+    [ApiKey.keyContentType]: ConstantRequestField.typeJson,
+    [ApiKey.keyXAuthToken]: params.paymentConfig.xAuthToken,
+  };
+  const body = {
+    [ApiKey.keySubscriberMsisdn]: params.mobileInitParams.subscriberNumber,
+    [ApiKey.keyChannelUserMsisdn]: params.mobileInitParams.channelUserNumber,
+    [ApiKey.keyAmount]: params.mobileInitParams.amount.toString(),
+    [ApiKey.keyDescription]: params.mobileInitParams.description,
+    [ApiKey.keyMobileOrderId]: params.mobileInitParams.transactionId,
+    [ApiKey.keyPin]: params.mobileInitParams.pinCode,
+    [ApiKey.keyMobilePayToken]: params.mobileInitParams.payToken,
+    [ApiKey.keyMobileNotifUrl]: params.mobileInitParams.notifUrl,
+  };
+
+  const dataValidation = validateData<InitPaymentBodySchema>(
+    body,
+    initPaymentBodySchema
+  );
+
+  if (!dataValidation.isValidData) {
+    return { schemaErrorMessage: dataValidation.message };
+  }
+
+  params.paymentConfig.logger.info(
+    `Initiate the ORANGE MONEY Payment with data: ${JSON.stringify(
+      body
+    )}\nroute: ${routes.mobileInitPayment()}`
+  );
+
+  const response = await postRequest<GenericRequestResponseData>({
+    logger: params.paymentConfig.logger,
+    headers: headers,
+    data: body,
+    route: routes.mobileInitPayment(),
+  });
+
+  return { requestResult: response };
+};
+
+/**
+ * Maps an API error message to the corresponding API error type.
+ *
+ * @param {string} message - the error message to map
+ * @return {ApiErrorType} the corresponding API error type
+ */
+const getApiErrorMessage = (message: string): ApiErrorType => {
+  switch (message) {
+    case OrangeMoneyErrorMessage.beneficiaryNotFound:
+      return ApiErrorType.invalidOrangeMoneyNumber;
+    case OrangeMoneyErrorMessage.insufficientFunds:
+      return ApiErrorType.insufficientFunds;
+    case OrangeMoneyErrorMessage.accountLocked:
+      return ApiErrorType.accountLocked;
+    case OrangeMoneyErrorMessage.invalidPaymentAmount:
+      return ApiErrorType.invalidPaymentAmount;
+    default:
+      return ApiErrorType.failedToInitiateThePayment;
+  }
+};

package/src/payments/payments.ts

@@ -0,0 +1,86 @@
+import { TargetEnvironment } from '../utils/utils';
+import { OrangeMoneyPaymentFake } from './implementations/fake';
+import { OrangeMoneyPaymentLive } from './implementations/live';
+import { OrangeMoneyPaymentParams } from './utils/joi_schema';
+import {
+  GetAccessTokenResponse,
+  GetOrangeMoneyPaymentRequest,
+  GetOrangeMoneyPaymentResponse,
+  GetPayTokenResponse,
+  InitializeOrangeMoneyRequest,
+  InitializeOrangeMoneyResponse,
+} from './utils/request_model';
+
+export interface OrangeMoneyPaymentInterface {
+  /**
+   * Gets the pay token token.
+   * @param {String} accessToken The access token for authorize the request.
+   * @returns {Promise<GetPayTokenResponse>} The promise that resolves to the pay token response.
+   */
+  getPayToken(accessToken: string): Promise<GetPayTokenResponse>;
+
+  /**
+   * Gets the access token token.
+   */
+  getAccessToken(): Promise<GetAccessTokenResponse>;
+
+  /**
+   * Initializes the orange money payment.
+   *
+   * @param {String} mobileInitParams.description the payment description.
+   * @param {String} mobileInitParams.subscriberNumber The phone number of the user making the payment.
+   * @param {String} mobileInitParams.channelUserNumber The phone number of the user receiving the payment.
+   * @param {String} mobileInitParams.transactionId Unique identifier of the customer transaction.
+   * @param {String} mobileInitParams.amount The amount of the transaction.
+   * @param {String} mobileInitParams.pinCode The Pin code of the ChannelUser.
+   * @param {String} mobileInitParams.notifUrl An http endpoint able to receive a post request.
+   * @param {String} mobileInitParams.payToken A payToken value useful to make payment
+   * and track the status of payment.
+   * @param {String} mobileInitParams.accessToken The access token for authorize the request.
+   * @returns {Promise<InitializeOrangeMoneyResponse>} The promise that resolves to the mobile payment initialization response.
+   **/
+  initializeOrangeMoneyPayment(
+    params: InitializeOrangeMoneyRequest
+  ): Promise<InitializeOrangeMoneyResponse>;
+
+  /**
+   * Gets The orange money payment status.
+   * @param {String} checkStatusParams.payToken unique identifier used to obtain payment status.
+   * @param {String} checkStatusParams.accessToken The access token for authorize the request.
+   * @returns {Promise<GetOrangeMoneyPaymentResponse>} The promise that resolves to the mobile payment status response.
+   */
+  getOrangeMoneyPaymentStatus(
+    params: GetOrangeMoneyPaymentRequest
+  ): Promise<GetOrangeMoneyPaymentResponse>;
+}
+
+/**
+ *  Creates a orange money payment.
+ */
+export class OrangeMoneyPayment {
+  /**
+   * Create a new payment using the provided configuration.
+   *
+   * @param {OrangeMoneyPaymentParams} config - The payment configuration.
+   *  - {TargetEnvironment} config.targetEnvironment the target environment.
+   *  - {string} config.apiUserName channelUser api username.
+   *  - {string} config.apiPassword channelUser api password.
+   *  - {string} config.xAuthToken the x-auth-token.
+   *  - {string} [mobileInitParams.omVersion] the mobile orange money version apply for payment request.The default orange money version
+   *        is 1.0.2: for more information: https://apiw.orange.cm/omcoreapis/1.0.2/mp/pay.
+   *  - {String} config.targetEnvironment the target environment.
+   * @return {OrangeMoneyPaymentInterface} The created payment.
+   */
+  static createPayment(
+    config: OrangeMoneyPaymentParams
+  ): OrangeMoneyPaymentInterface {
+    switch (config.targetEnvironment) {
+      case TargetEnvironment.prod:
+        return new OrangeMoneyPaymentLive(config);
+      case TargetEnvironment.fake:
+        return new OrangeMoneyPaymentFake();
+      default:
+        return new OrangeMoneyPaymentLive(config);
+    }
+  }
+}