MoneyHash

https://docs.moneyhash.io/docs
Admin
MoneyHash is a payment infrastructure Super-API that simplifies payments and revenue operations in...
Tokens:297,803
Snippets:2,002
Trust Score:8.2
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install MoneyHash SDK

Source: https://docs.moneyhash.io/docs/basics-concepts

Commands to install the MoneyHash JavaScript SDK using standard package managers. Supports both npm and yarn environments.

```Shell
npm install @moneyhash/js-sdk

# or

yarn add @moneyhash/js-sdk
```

--------------------------------

### Quick Start: Google Pay Integration with MoneyHash (JavaScript)

Source: https://docs.moneyhash.io/docs/google-pay

This snippet demonstrates the quick start implementation for Google Pay using MoneyHash. It covers fetching configuration, setting up the Google Pay button, and handling the payment token submission.

```jsx
// 1. Get config from MoneyHash
const { expressMethods } = await moneyHash.getMethods({ currency: '<currency'>, amount: '<amount>');
const googlePayMethod = expressPayMethods.find(method => method.id === 'GOOGLE_PAY');
const googlePayNativeData = googlePayMethod?.nativePayData;

// 2. Configure Google Pay button
button.paymentRequest = {
  apiVersion: 2,
  allowedPaymentMethods: [{
    type: "CARD",
    parameters: {
      allowedAuthMethods: ["PAN_ONLY", "CRYPTOGRAM_3DS"],
      allowedCardNetworks: ["VISA", "MASTERCARD"]
    },
    tokenizationSpecification: {
      type: "PAYMENT_GATEWAY",
      parameters: {
        gateway: "moneyhash",
        gatewayMerchantId: googlePayNativeData.gateway_merchant_id
      }
    }
  }],
  merchantInfo: {
    merchantId: googlePayNativeData.merchant_id,
    merchantName: googlePayNativeData.merchant_name,
  },
  transactionInfo: {
    totalPrice: googlePayNativeData.amount,
    currencyCode: googlePayNativeData.currency_code,
    countryCode: googlePayNativeData.country_code
  }
};

// 3. Handle token from Google Pay
button.addEventListener("loadpaymentdata", async (event) => {
  const { paymentMethodData, email } = event.detail;
  const paymentToken = paymentMethodData.tokenizationData.token;
  const googlePayReceipt = {
    receipt: paymentToken,
    receiptBillingData: {
      email,
    },
  };
  
  await moneyHash.proceedWith({
    type: "method",
    id: "GOOGLE_PAY",
    intentId,
  });

  // Submit the Google Pay payment token
  const intentDetails = await moneyHash.submitPaymentReceipt({
    intentId,
    nativeReceiptData: googlePayReceipt,
  });

  console.log("Payment successful:", intentDetails);
});
```

--------------------------------

### Install Google Pay SDK for Web Components, React, and Angular

Source: https://docs.moneyhash.io/docs/google-pay

Install the Google Pay SDK tailored for your specific frontend framework. This step is crucial for enabling Google Pay functionality in your application.

```shell
npm install @google-pay/button-element
```

```shell
npm install @google-pay/button-react
```

```shell
npm install @google-pay/button-angular
```

--------------------------------

### Install MoneyHash Flutter SDK

Source: https://docs.moneyhash.io/docs/flutter-sdk

Commands to add the MoneyHash payment package to a Flutter project via terminal or pubspec.yaml file.

```bash
flutter pub add moneyhash_payment
```

```yaml
dependencies:
  moneyhash_payment: ^{{latest_version}}
```

--------------------------------

### MoneyHash SDK Card Form Usage Example

Source: https://docs.moneyhash.io/docs/moneyhash-sdk-cardform-documentation-3

This Kotlin example demonstrates initializing the MoneyHash SDK and CardForm, collecting card data, and processing a payment. It includes error handling for SDK initialization and card operations. Requires a public API key and payment intent ID.

```kotlin
// Initialize MoneyHashSDK and set the public key
val sdkBuilder = MoneyHashSDKBuilder()
    .setPublicKey("your_public_api_key")
val moneyHashSDK = sdkBuilder.build()

// Initialize CardFormBuilder and subscribe to field changes
val cardFormBuilder = CardFormBuilder()
    .setCardNumberField { state ->
        println("Card Number Field Updated: $state")
    }
    .setCVVField { state ->
        println("CVV Field Updated: $state")
    }
    .setCardHolderNameField { state ->
        println("Card Holder Name Field Updated: $state")
    }
    .setExpireMonthField { state ->
        println("Expire Month Field Updated: $state")
    }
    .setExpireYearField { state ->
        println("Expire Year Field Updated: $state")
    }
    .setCardBrandChangeListener { brand ->
        println("Card Brand Changed: $brand")
    }

try {
    val cardForm = cardFormBuilder.build()

    // Collect card data
    CoroutineScope(Dispatchers.Main).launch {
        try {
            val cardData = cardForm.collect()
            if (cardData != null) {
                println("Card data collected: $cardData")

                // Process payment
                val intentDetails = cardForm.pay(
                    intentId = "payment_intent_id",
                    cardData = cardData,
                    saveCard = true,
                    billingData = mapOf("address" to "123 Main St", "city" to "New York"),
                    shippingData = mapOf("address" to "456 Elm St", "city" to "Boston")
                )
                println("Payment processed successfully: $intentDetails")
            } else {
                println("Failed to collect card data.")
            }
        } catch (error: MHThrowable) {
            println("Error during card operations: ${error.message}")
        }
    }
} catch (error: MHThrowable) {
    println("Error building CardForm: ${error.message}")
}
```

--------------------------------

### Error Handling Example

Source: https://docs.moneyhash.io/docs/google-pay

Demonstrates how to implement error handling for common payment scenarios when using MoneyHash with Google Pay.

```APIDOC
```jsx
try {
  await moneyHash.proceedWith({
    type: "method",
    id: "GOOGLE_PAY",
    intentId,
  });

  const result = await moneyHash.submitPaymentReceipt({
    intentId,
    nativeReceiptData: googlePayReceipt,
  });
  
} catch (error) {
  switch (error.code) {
    case 'PAYMENT_METHOD_NOT_AVAILABLE':
      // Handle when Google Pay is not available
      break;
    case 'PAYMENT_CANCELLED':
      // Handle when user cancels payment
      break;
    case 'PAYMENT_FAILED':
      // Handle payment processing failures
      break;
    default:
      // Handle other errors
      console.error('Payment error:', error);
  }
}
```
```

--------------------------------

### API Response Example (200 OK)

Source: https://docs.moneyhash.io/docs/post_api-v1-1-external-payments-intent

This is an example of a successful API response (HTTP 200) when creating a payment intent. It indicates that the request was processed successfully.

```json
{
  "success": true
}
```

--------------------------------

### Javascript SDK Integration

Source: https://docs.moneyhash.io/docs/version-0

Methods for initializing the MoneyHash SDK and rendering the checkout iframe.

```APIDOC
## Javascript SDK Initialization

### Description
Initialize the MoneyHash instance and render the payment iframe into your application.

### Code Example
```typescript
import MoneyHash from "@moneyhash/js-sdk";

// 1. Initialize instance
const moneyHash = new MoneyHash({ type: "payment" });

// 2. Render the iframe
await moneyHash.start({
  selector: "#payment-container",
  intentId: "int_123456789",
});
```
```

--------------------------------

### Example Usage of CardInputFieldState (Kotlin)

Source: https://docs.moneyhash.io/docs/collect-card-information-4

Demonstrates how to create and use an instance of the CardInputFieldState class. This example shows how to initialize the state with specific values and access its properties to display information about the card number's validity.

```kotlin
val cardInputState = CardInputFieldState(
    isValid = true,
    errorMessage = null,
    isOnFocused = true,
    inputLength = 16
)
println("Card Number is valid: ${cardInputState.isValid}")
```

--------------------------------

### Initialize MoneyHashSDKBuilder

Source: https://docs.moneyhash.io/docs/ios-sdk-api-documentation

Initializes a new instance of MoneyHashSDKBuilder to start the configuration process for setting up the MoneyHashSDK.

```swift
public class MoneyHashSDKBuilder {
    public init()
    public func setPublicKey(_ key: String) -> MoneyHashSDKBuilder
    public func build() -> MoneyHash
}
```

```swift
let sdkBuilder = MoneyHashSDKBuilder()
```

--------------------------------

### GET /installment-plans

Source: https://docs.moneyhash.io/docs/installment-plans

Retrieve available installment plans directly from the payment provider without creating an intent.

```APIDOC
## GET /installment-plans

### Description
Retrieves a list of installment plans based on card details and transaction amount without requiring an intent.

### Method
GET

### Parameters
#### Query Parameters
- **first6Digits** (string) - Required - The first six digits of the customer's card.
- **amount** (number) - Required - The transaction amount.
- **currency** (string) - Required - The currency code (e.g., USD, EGP).

### Request Example
```javascript
moneyhash.getInstallmentPlans({
  first6Digits: "400000",
  amount: 1000,
  currency: "USD"
});
```

### Response
#### Success Response (200)
- **plans** (array) - List of available installment plan objects.

#### Response Example
```json
[
  {
    "id": "plan_123",
    "installmentPeriod": 3,
    "amount": { "value": "1000", "formatted": 333.33, "currency": "USD" },
    "interestRate": "0",
    "upfrontFees": "0"
  }
]
```
```

--------------------------------

### Initialize MoneyHash SDK

Source: https://docs.moneyhash.io/docs/basics-concepts

Demonstrates how to import and instantiate the MoneyHash headless SDK. Requires specifying the integration type and a public API key for payment operations.

```TypeScript
import MoneyHash from '@moneyhash/js-sdk/headless';

const moneyHash = new MoneyHash({
  type: "payment" | "payout",
  publicApiKey: "<account_public_api_key>", // available for payment type only
});
```

--------------------------------

### Initialize SDK with Public Key

Source: https://docs.moneyhash.io/docs/basic-concepts-3

This section demonstrates how to initialize the MoneyHash SDK by setting your public API key during the builder phase.

```APIDOC
## POST /initialize

### Description
Initializes the MoneyHash SDK with a provided public API key.

### Method
POST

### Endpoint
/initialize

### Parameters
#### Query Parameters
- **publicKey** (string) - Required - Your unique public API key for authentication.

### Request Example
```kotlin
// Initialize the SDK using the builder
val sdkBuilder = MoneyHashSDKBuilder()
sdkBuilder.setPublicKey("your_public_api_key")
val moneyHashSDK = sdkBuilder.build()

println("Public key set successfully")
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message indicating successful initialization.

#### Response Example
```json
{
  "message": "SDK initialized successfully"
}
```
```

--------------------------------

### Get Payment Link Status (PHP)

Source: https://docs.moneyhash.io/docs/get-payment-link-status

A PHP example for retrieving a payment link's status via the Moneyhash API. This code uses cURL to send the GET request and handle the JSON response.

```php
<?php

function getPaymentLinkStatus($paymentLinkId) {
    $url = "https://web.moneyhash.io/api/v1.4/payment_links/{$paymentLinkId}/status/";
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('accept: application/json'));
    
    $response = curl_exec($ch);
    if (curl_errno($ch)) {
        echo 'Curl error: ' . curl_error($ch);
        return null;
    }
    curl_close($ch);
    
    return json_decode($response, true);
}

// Example usage:
// $status = getPaymentLinkStatus('your_payment_link_id');
// print_r($status);

?>
```

--------------------------------

### Retrieve Installment Plans Directly (TypeScript)

Source: https://docs.moneyhash.io/docs/installment-plans

Explains how to get a list of installment plans directly from the payment provider without creating an intent. This requires initializing `MoneyHash` with a `publicApiKey` and providing card details, amount, and currency. The result is logged to the console.

```typescript
const plans = moneyhash.getInstallmentPlans({
  first6Digits,
  amount,
  currency,
});

console.log(plans);
```

--------------------------------

### POST /api/v1.4/subscriptions/plans/

Source: https://docs.moneyhash.io/docs/v11_subscriptions_plans_create

Creates a new subscription plan with specific recurrency, trial, and discount settings.

```APIDOC
## POST /api/v1.4/subscriptions/plans/

### Description
Creates a new subscription plan. This endpoint allows you to define the billing interval, trial duration, and optional discount parameters for a subscription.

### Method
POST

### Endpoint
https://web.moneyhash.io/api/v1.4/subscriptions/plans/

### Parameters
#### Request Body
- **recurrency** (integer) - Required - The interval at which subscription is charged.
- **recurrency_unit** (string) - Required - The time unit (DAY or MONTH).
- **trial_period** (integer) - Optional - Number of trial days before the first recurring cycle.
- **recurring_cycles** (integer) - Optional - Total number of payment cycles; if empty, charges forever.
- **discount_amount** (string) - Optional - Fixed discount amount.
- **discount_percentage** (string) - Optional - Discount percentage.
- **discount_cycles** (integer) - Optional - Number of cycles to apply the discount.

### Request Example
{
  "currency": "usd",
  "recurrency": 1,
  "recurrency_unit": "DAY"
}

### Response
#### Success Response (200)
- **id** (string) - The unique identifier of the created plan.

#### Response Example
{
  "status": "success",
  "plan_id": "plan_12345"
}
```

--------------------------------

### Get Payment Link Status (Node.js)

Source: https://docs.moneyhash.io/docs/get-payment-link-status

Example of fetching a payment link's status using Node.js. This snippet would typically use a library like 'axios' or the built-in 'https' module to make the GET request to the specified API endpoint.

```javascript
// Node.js example (using fetch API, available in Node.js 18+)
async function getPaymentLinkStatus(paymentLinkId) {
  const url = `https://web.moneyhash.io/api/v1.4/payment_links/${paymentLinkId}/status/`;
  try {
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'accept': 'application/json'
      }
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching payment link status:', error);
    return null;
  }
}

// Example usage:
// getPaymentLinkStatus('your_payment_link_id').then(status => console.log(status));
```

--------------------------------

### Initialize SDK with Public Key (Kotlin)

Source: https://docs.moneyhash.io/docs/basic-concepts-3

Initializes the MoneyHash SDK using a builder pattern and sets the public API key. Replace 'your_public_api_key' with your actual key. This is a prerequisite for using other SDK functionalities.

```kotlin
val sdkBuilder = MoneyHashSDKBuilder()
sdkBuilder.setPublicKey("your_public_api_key")
val moneyHashSDK = sdkBuilder.build()

println("Public key set successfully")
```

--------------------------------

### Get Intent Methods

Source: https://docs.moneyhash.io/docs/version-0

Retrieves available payment methods, saved cards, and customer balances for a given intent.

```APIDOC
## GET /getIntentMethods

### Description
Fetches the available payment methods, saved cards, and customer balances associated with a specific intent.

### Method
GET

### Endpoint
/getIntentMethods

### Parameters
#### Query Parameters
- **intentId** (string) - Required - The identifier for the payment or payout intent.

### Request Example
(No request body, uses query parameter)

### Response
#### Success Response (200)
- **paymentMethods** (array) - List of available payment methods.
- **expressMethods** (array) - List of available express payment methods.
- **savedCards** (array) - List of customer's saved cards.
- **customerBalances** (array) - List of customer's balances.

#### Response Example
```json
{
  "paymentMethods": [...],
  "expressMethods": [...],
  "savedCards": [...],
  "customerBalances": [...]
}
```
```

--------------------------------

### Initialize and Authenticate MoneyHash SDK

Source: https://docs.moneyhash.io/docs/flutter-sdk

Steps to import the SDK, instantiate the client, and authenticate using a public API key.

```dart
import 'package:moneyhash/moneyhash.dart';

final MoneyHashSDK moneyHashSDK = MoneyHashSDK();
moneyHashSDK.setPublicKey("your_public_api_key");
```

--------------------------------

### SDK: Get Intent Details

Source: https://docs.moneyhash.io/docs/version-0

Retrieves the current state and details of a payment intent using the MoneyHash JavaScript SDK.

```APIDOC
## SDK Method: getIntentDetails

### Description
Retrieves the details of an intent using the `intent_id` obtained from the creation step. The returned `state` determines the next UI action required.

### Usage
```typescript
moneyHash.getIntentDetails("<intent_id>").then(({ intent, state }) => {
  console.log(state);
});
```

### State Actions
- **METHOD_SELECTION**: Use `getIntentMethods` to list available payment options.
- **INTENT_FORM**: Use `renderForm` to display the payment UI.
- **INTENT_PROCESSED**: Display success confirmation.
- **TRANSACTION_FAILED**: Display failure UI.
- **TRANSACTION_WAITING_USER_ACTION**: Display pending action UI.
- **EXPIRED/CLOSED**: Display appropriate status UI.
```

--------------------------------

### GET /getMethods

Source: https://docs.moneyhash.io/docs/migration-guide-upgrading-from-moneyhash-sdk-for-react-native-version-20-to-21

Retrieves available payment methods for a specific intent or transaction configuration.

```APIDOC
## getMethods

### Description
Fetches payment methods based on provided intent details or transaction parameters.

### Method
GET

### Parameters
#### Request Body
- **intentId** (string) - Optional - The ID of the intent.
- **intentType** (string) - Optional - The type of the intent.
- **currency** (string) - Optional - Transaction currency.
- **amount** (number) - Optional - Transaction amount.
- **customer** (string) - Optional - Customer identifier.
- **flowId** (string) - Optional - Flow identifier.

### Response
#### Success Response (200)
- **IntentMethods** (object) - A list of available payment methods.

### Response Example
```json
{
  "methods": ["card", "wallet"]
}
```
```

--------------------------------

### Create Subscription Plan using cURL

Source: https://docs.moneyhash.io/docs/v11_subscriptions_plans_create

This snippet demonstrates how to create a subscription plan using a cURL request. It includes the necessary headers and a JSON payload specifying plan details like currency and recurrence unit. Ensure you replace placeholders with your actual API key and desired values.

```shell
curl --request POST \
     --url https://web.moneyhash.io/api/v1.4/subscriptions/plans/ \
     --header 'accept: application/json' \
     --header 'content-type: application/json' \
     --data '{
  "currency": "usd",
  "recurrency_unit": "DAY"
}'
```

--------------------------------

### Submit Form Data with MoneyHash SDK

Source: https://docs.moneyhash.io/docs/basic-concepts

Demonstrates initializing the MoneyHash SDK, extracting billing and shipping fields from intent states, and submitting the collected data to process a payment.

```dart
import 'package:moneyhash_payment/moneyhash_payment.dart';

final moneyHashSDK = MoneyHashSDKBuilder()
    .setPublicKey("your_public_key")
    .build();

Future<void> submitPayment(IntentDetails intentDetails) async {
  try {
    Map<String, String> billingData = {};
    Map<String, String> shippingData = {};

    if (intentDetails.intentState is FormFields) {
      FormFields formFields = intentDetails.intentState as FormFields;
      formFields.billingFields?.forEach((field) {
        billingData[field.name] = 'user_input_value';
      });
      formFields.shippingFields?.forEach((field) {
        shippingData[field.name] = 'user_input_value';
      });
    }

    VaultData? cardData;

    IntentDetails? submittedIntentDetails = await moneyHashSDK.submitForm(
      intentDetails.intent?.id ?? '',
      intentDetails.selectedMethod ?? '',
      billingData,
      shippingData,
      cardData,
      true
    );

    print('Form submitted successfully: $submittedIntentDetails');
  } catch (error) {
    print('Error submitting form: $error');
  }
}
```

--------------------------------

### POST /v1/plans

Source: https://docs.moneyhash.io/docs/manage-plans

Create a new subscription plan to define pricing, currency, and features for customer enrollment.

```APIDOC
## POST /v1/plans

### Description
Creates a new subscription plan within MoneyHash to facilitate customer enrollment and recurring billing.

### Method
POST

### Endpoint
/v1/plans

### Parameters
#### Request Body
- **amount** (decimal) - Required - The cost of the subscription plan.
- **currency** (string) - Required - The ISO currency code for the plan (e.g., USD, EGP).
- **name** (string) - Required - The display name of the subscription plan.
- **interval** (string) - Required - The billing cycle interval (e.g., monthly, yearly).

### Request Example
{
  "name": "Premium Monthly",
  "amount": 99.99,
  "currency": "USD",
  "interval": "monthly"
}

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the created plan.
- **status** (string) - The current status of the plan.

#### Response Example
{
  "id": "plan_123456789",
  "status": "active"
}
```

--------------------------------

### GET /getMethods

Source: https://docs.moneyhash.io/docs/migration-guide-upgrading-from-moneyhash-sdk-for-flutter-version-20-to-21

Retrieves payment methods for a given intent or transaction context. Replaces the deprecated getIntentMethods.

```APIDOC
## GET /getMethods

### Description
Retrieves available payment methods. Requires the public API key to be set via `setPublicKey` prior to invocation.

### Method
GET

### Endpoint
/getMethods

### Parameters
#### Request Body
- **methodsParams** (GetMethodsParams) - Required - Object containing either intent details or currency/customer/flow/amount details.

### Request Example
{
  "methodsParams": {
    "intentId": "int_123",
    "intentType": "payment"
  }
}

### Response
#### Success Response (200)
- **IntentMethods** (Object) - The list of available payment methods.

#### Response Example
{
  "methods": ["card", "wallet", "bank_transfer"]
}
```

--------------------------------

### Set Public Key Example

Source: https://docs.moneyhash.io/docs/basic-concepts-1

Shows how to set the public API key for SDK authentication using the `setPublicKey` method. This method should be called early in the application's initialization. Replace the placeholder with your actual public API key. Errors are handled and logged.

```javascript
try {
  // Set the public API key
  moneyHash.setPublicKey('<your-public-api-key>');
  console.log('Public key set successfully');
} catch (e) {
  // Handle error if setting the public key fails
  console.error('Error setting public key:', e.message);
}
```

--------------------------------

### Initialize MoneyHash SDK with Builder

Source: https://docs.moneyhash.io/docs/moneyhash-sdk-api-documentation

Demonstrates how to use the MoneyHashSDKBuilder to configure Google Pay settings and instantiate the MoneyHashSDK. This is the primary entry point for SDK setup.

```dart
import 'package:moneyhash/moneyhash.dart';

void main() {
  var googlePayConfig = NativeGooglePayConfig(
    environment: GooglePayEnvironment.test,
    allowedCards: [AllowedCards.visa, AllowedCards.mastercard],
    supportedMethods: [SupportedMethods.pan_only, SupportedMethods.cryptogram_3ds],
  );

  var moneyHashSDK = MoneyHashSDKBuilder()
    .setNativeGooglePayConfig(googlePayConfig)
    .build();

  print("MoneyHash SDK initialized with Google Pay configuration.");
}
```

--------------------------------

### Get Available Payment Methods (TypeScript)

Source: https://docs.moneyhash.io/docs/version-0

Retrieves available pay-in/pay-out methods, saved cards, and customer balances for a given intent. This information can be used to predefine or display payment options to the customer.

```typescript
moneyHash
  .getIntentMethods("<intent_id>")
  .then(({ paymentMethods, expressMethods, savedCards, customerBalances }) => {
    console.log({
      paymentMethods,
      expressMethods,
      savedCards,
      customerBalances,
    });
  });
```

--------------------------------

### Initialize MoneyHashSDK with Google Pay Configuration

Source: https://docs.moneyhash.io/docs/android-sdk-apis-documentation

Demonstrates how to use the MoneyHashSDKBuilder to configure the SDK, including setting the public key and native Google Pay parameters for Android development.

```kotlin
val sdkBuilder = MoneyHashSDKBuilder()

sdkBuilder.setPublicKey("your_public_api_key")

val googlePayConfig = NativeGooglePayConfig(
    environment = GooglePayEnvironment.TEST,
    allowedCards = listOf(AllowedCards.VISA, AllowedCards.MASTERCARD),
    supportedMethods = listOf(SupportedMethods.PAN_ONLY)
)
sdkBuilder.setNativeGooglePayConfig(googlePayConfig)

val moneyHashSDK = sdkBuilder.build()

moneyHashSDK.setLogLevel(LogLevel.Debug)
```

--------------------------------

### Refactor CardCollector to CardForm in Dart

Source: https://docs.moneyhash.io/docs/migration-guide-upgrading-from-moneyhash-sdk-for-flutter-version-20-to-21

This code example illustrates the refactoring of `CardCollector` to `CardForm` in the MoneyHash SDK. It shows the updated way to build and use the `CardForm` for collecting card data, highlighting the removal of parameters from the `collect` method and the prerequisite of setting the public API key.

```dart
CardCollector cardCollector = cardFormBuilder.build();
VaultData? cardData = await cardCollector.collect("intentId", true);

moneyHashSDK.setPublicKey("your_public_api_key"); // Ensure the public key is set

CardForm cardForm = cardFormBuilder.build();
// Configure cardForm as needed
VaultData? cardData = await cardForm.collect();
```

--------------------------------

### Display Installment Plans in Intent State (TypeScript)

Source: https://docs.moneyhash.io/docs/installment-plans

Shows the structure of intent details when installment plans are available. The `plans` array within `stateDetails` lists available options, each with an ID, installment period, amount, and interest rate. This is part of the intent lifecycle.

```typescript
{
  state: "INSTALLMENT_PLANS",
  stateDetails: {
    plans: [
      {
        id: "<plan-id>",
        installmentPeriod: 3,
        amount: {
          value: "value", // amount with currency
          formatted: 60.92, // amount as number
          currency: "currency",
        },
        interestRate: "<interest-rate>" | null,
        upfrontFees: "<upfront-fees>" | null,
        issuerCode?: "<issuer-code>" // optional field
      },
    ],
  }
}
```

--------------------------------

### Configure SDK Locale and Language

Source: https://docs.moneyhash.io/docs/basics-concepts

Demonstrates how to initialize the MoneyHash instance with a specific locale and how to update the language programmatically during runtime.

```typescript
const moneyHash = new MoneyHash({
  type: "payment" | "payout",
  locale: "ar-EG",
});

await moneyHash.setLocale("<locale_code>");
```

--------------------------------

### Select Installment Plan (TypeScript)

Source: https://docs.moneyhash.io/docs/installment-plans

Demonstrates how to select a specific installment plan after they have been displayed to the user. This function, `moneyhash.selectInstallmentPlan`, takes the `intentId`, `planId`, and optionally `issuerCode` to proceed with the payment, returning updated intent details.

```typescript
const intentDetails = await moneyhash.selectInstallmentPlan({
  intentId: "<intent-id>",
  planId: "<plan-id>",
  issuerCode?: "<issuer-code>" // optional, pass it if received in plan details
});
```

--------------------------------

### Submit Payment Form via MoneyHash SDK

Source: https://docs.moneyhash.io/docs/basic-concepts-3

Illustrates the initialization of the MoneyHash SDK and the usage of the submitForm method to process collected billing, shipping, and card data.

```kotlin
import com.moneyhash.sdk.android.core.MoneyHashSDKBuilder

val moneyHashSDK = MoneyHashSDKBuilder
    .setPublicKey("your_public_key")
    .build()

fun submitPayment(intentState: IntentStateDetails) {
    try {
        var billingData: Map<String, String>? = null
        var shippingData: Map<String, String>? = null

        if (intentState is IntentStateDetails.FormFields) {
            billingData = intentState.billingFields?.associate { it.name to "user_input_value" }
            shippingData = intentState.shippingFields?.associate { it.name to "user_input_value" }
        }

        val cardData: VaultData? = null

        val intentDetails = moneyHashSDK.submitForm(
            intentId = "your_intent_id",
            selectedMethod = "selected_method_id",
            billingData = billingData,
            shippingData = shippingData,
            cardData = cardData,
            saveCard = true
        )

        println("Form submitted successfully: $intentDetails")
    } catch (throwable: Throwable) {
        println("Error submitting form: ${throwable.message}")
    }
}
```

--------------------------------

### Get Payment Link Status (Python)

Source: https://docs.moneyhash.io/docs/get-payment-link-status

This Python script demonstrates how to fetch the status of a payment link using the Moneyhash API. It utilizes the 'requests' library for making the HTTP GET request.

```python
import requests

def get_payment_link_status(payment_link_id):
    url = f"https://web.moneyhash.io/api/v1.4/payment_links/{payment_link_id}/status/"
    headers = {
        'accept': 'application/json'
    }
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching payment link status: {e}")
        return None

# Example usage:
# status = get_payment_link_status('your_payment_link_id')
# if status:
#     print(status)
```

--------------------------------

### Apply Custom Styles and Render Form in Kotlin

Source: https://docs.moneyhash.io/docs/basic-concepts-3

Initializes the MoneyHash SDK, aggregates custom styles into an EmbedStyle object, and renders the payment form using the renderForm method.

```kotlin
val sdkBuilder = MoneyHashSDKBuilder()
sdkBuilder.setPublicKey("your_public_api_key")
val moneyHashSDK = sdkBuilder.build()

val customEmbedStyle = EmbedStyle(
    submitButton = buttonStyle,
    loader = loaderStyle,
    input = inputStyle
)

val activityResultLauncher: ActivityResultLauncher<IntentCreationParams> = // initialize your launcher

moneyHashSDK.renderForm(
    intentId = "your_intent_id",
    intentType = IntentType.Payment,
    embedStyle = customEmbedStyle,
    launcher = activityResultLauncher
)
```

--------------------------------

### POST /select-installment-plan

Source: https://docs.moneyhash.io/docs/installment-plans

Selects a specific installment plan for an existing intent to proceed with payment.

```APIDOC
## POST /select-installment-plan

### Description
Updates the intent lifecycle by selecting a specific installment plan for the transaction.

### Method
POST

### Request Body
- **intentId** (string) - Required - The unique identifier of the payment intent.
- **planId** (string) - Required - The ID of the selected installment plan.
- **issuerCode** (string) - Optional - The issuer code if provided by the plan details.

### Request Example
```javascript
moneyhash.selectInstallmentPlan({
  intentId: "intent_abc123",
  planId: "plan_789",
  issuerCode: "bank_01"
});
```

### Response
#### Success Response (200)
- **intentDetails** (object) - The updated intent object reflecting the selected plan.
```

--------------------------------

### POST /subscriptions/{simulation_subscription}/simulate

Source: https://docs.moneyhash.io/docs/manage-subscriptions

This endpoint allows developers to trigger specific subscription lifecycle events in the sandbox environment to test system behavior without waiting for real-time events.

```APIDOC
## POST /subscriptions/{simulation_subscription}/simulate

### Description
Simulates subscription lifecycle events such as advancing to the next cycle start date or marking all issued invoices as paid.

### Method
POST

### Endpoint
/subscriptions/{simulation_subscription}/simulate

### Parameters
#### Path Parameters
- **simulation_subscription** (string) - Required - The unique identifier of the subscription to simulate.

#### Request Body
- **command** (string) - Required - The action to perform. Options: `jump_to_the_next_cycle_start_date`, `pay_all_issued_invoices`.

### Request Example
{
  "command": "jump_to_the_next_cycle_start_date"
}

### Response
#### Success Response (200)
- **status** (string) - The result of the simulation command.

#### Response Example
{
  "status": "success"
}
```

--------------------------------

### Submit CVV with Installment Plan Data (TypeScript)

Source: https://docs.moneyhash.io/docs/installment-plans

Illustrates how to include installment plan selection during the CVV submission process. The `submitCvv` function now accepts an optional `installmentPlanData` object, which should contain the `planId` and `issuerCode` of the chosen plan.

```typescript
const res = await submitCvv({
  intentId,
  cvv,
  installmentPlanData: {
  	planId: "<plan-id>",
    issuerCode: "<issuer-code>" // send it if received in plan item
  },
});
```

--------------------------------

### Get Payment Link Status (Ruby)

Source: https://docs.moneyhash.io/docs/get-payment-link-status

This Ruby code snippet shows how to make a GET request to the Moneyhash API to check the status of a payment link. It utilizes the 'net/http' library for making HTTP requests.

```ruby
require 'net/http'
require 'uri'

def get_payment_link_status(payment_link_id)
  uri = URI.parse("https://web.moneyhash.io/api/v1.4/payment_links/#{payment_link_id}/status/")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Get.new(uri.request_uri)
  request['accept'] = 'application/json'

  response = http.request(request)
  if response.is_a?(Net::HTTPSuccess)
    JSON.parse(response.body)
  else
    puts "Error: #{response.code} #{response.message}"
    nil
  end
end

# Example usage:
# status = get_payment_link_status('your_payment_link_id')
# puts status.inspect
```

--------------------------------

### Create Sync Provider using Ruby

Source: https://docs.moneyhash.io/docs/create-sync-provider

This Ruby example shows how to create a sync provider using the 'net/http' library. It constructs an HTTP POST request with the necessary headers and JSON body. This is a standard way to handle API requests in Ruby.

```ruby
require 'net/http'
require 'uri'
require 'json'

def create_sync_provider(form_id, is_live)
  uri = URI.parse('https://web.moneyhash.io/api/v1/providers/sync/available/')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = (uri.scheme == 'https')

  request = Net::HTTP::Post.new(uri.request_uri)
  request['accept'] = 'application/json'
  request['content-type'] = 'application/json'
  request.body = { form_id: form_id, is_live: is_live }.to_json

  begin
    response = http.request(request)
    if response.code.to_i >= 200 && response.code.to_i < 300
      return JSON.parse(response.body)
    else
      puts "Error creating sync provider. Status code: #{response.code}"
      puts "Response body: #{response.body}"
      return nil
    end
  rescue Net::HTTPError => e
    puts "HTTP Error: #{e.message}"
    return nil
  rescue StandardError => e
    puts "An error occurred: #{e.message}"
    return nil
  end
end

# Example usage:
# result = create_sync_provider('your_form_id', true)
# if result
#   puts result
# end
```

--------------------------------

### Install MoneyHash React Native SDK

Source: https://docs.moneyhash.io/docs/react-native-sdk

Commands to install the MoneyHash SDK dependency using npm or yarn package managers.

```bash
npm install @moneyhash/reactnative-sdk
```

```bash
yarn add @moneyhash/reactnative-sdk
```

--------------------------------

### GET /api/v1.4/payment_links/{payment_link_id}/status/

Source: https://docs.moneyhash.io/docs/get-payment-link-status

Retrieves the current status details for a specific payment link using its unique identifier.

```APIDOC
## GET /api/v1.4/payment_links/{payment_link_id}/status/

### Description
Retrieves the current status details for a specific payment link using its unique identifier.

### Method
GET

### Endpoint
https://web.moneyhash.io/api/v1.4/payment_links/{payment_link_id}/status/

### Parameters
#### Path Parameters
- **payment_link_id** (string) - Required - A unique identifier for the payment intent.

#### Query Parameters
None

#### Request Body
None

### Request Example
```curl
curl --request GET \
     --url https://web.moneyhash.io/api/v1.4/payment_links/payment_link_id/status/ \
     --header 'accept: application/json'
```

### Response
#### Success Response (200)
- **status** (string) - The current status of the payment link (e.g., 'paid', 'pending', 'expired').
- **created_at** (string) - Timestamp when the payment link was created.
- **expires_at** (string) - Timestamp when the payment link will expire.

#### Response Example
```json
{
  "status": "paid",
  "created_at": "2023-10-27T10:00:00Z",
  "expires_at": "2023-11-26T10:00:00Z"
}
```

#### Error Responses
- **401** - Unauthorized API key.
- **404** - Invalid payment link id.
```

--------------------------------

### Create Intent API

Source: https://docs.moneyhash.io/docs/direct-api

Initiates a payment by creating an intent. This is the first step for every payment and provides the necessary information to present payment options to the customer.

```APIDOC
## POST /api/v1.4/direct/payments/intent/

### Description
Creates a payment intent, which is the initial step in the payment process. The response contains details about available payment methods for the specified currency and account.

### Method
POST

### Endpoint
/api/v1.4/direct/payments/intent/

### Parameters
#### Query Parameters
None

#### Request Body
* **currency** (string) - Required - The currency for the payment.
* **account** (string) - Required - The account identifier.

### Request Example
```json
{
  "currency": "USD",
  "account": "merchant_account_id"
}
```

### Response
#### Success Response (200)
* **intent_id** (string) - The unique identifier for the created intent.
* **state** (string) - The current state of the intent (e.g., METHOD_SELECTION).
* **state_details** (object) - Contains details specific to the current state, such as available payment methods or form fields.

#### Response Example
```json
{
  "intent_id": "int_abc123xyz",
  "state": "METHOD_SELECTION",
  "state_details": {
    "payment_methods": [
      {
        "type": "CARD",
        "name": "Credit/Debit Card"
      },
      {
        "type": "BANK_TRANSFER",
        "name": "Bank Transfer"
      }
    ]
  }
}
```
```

--------------------------------

### Select Installment Plan for Payment Intent (Swift)

Source: https://docs.moneyhash.io/docs/ios-sdk-api-documentation

Selects a specific installment plan for a given payment intent. This method updates the payment intent with the user's chosen plan. It requires the intent ID and installment plan data, returning updated intent details or throwing an error if the selection fails.

```swift
func selectInstallmentPlan(
    intentId: String,
    installmentPlanData: InstallmentPlanData
) async throws -> IntentDetails?
```

```swift
do {
    let installmentPlanData = InstallmentPlanData(id: "plan_id_123", issuerCode: "issuer_code_456")
    if let intentDetails = try await moneyHashSDK.selectInstallmentPlan(
        intentId: "intent_id",
        installmentPlanData: installmentPlanData
    ) {
        print("Installment plan selected successfully: (intentDetails)")
    } else {
        print("No intent details returned after selecting installment plan.")
    }
} catch {
    print("Error selecting installment plan: (error)")
}
```

--------------------------------

### Initialize and Handle Card Form Payments in Kotlin

Source: https://docs.moneyhash.io/docs/pay-using-card-information-3

This Kotlin code demonstrates how to initialize a CardForm using CardFormBuilder, set up listeners for various card fields and brand changes, and handle payment processing. It includes a ViewModel to manage the form state and a Composable function to render the UI elements for card input and payment submission. Dependencies include Jetpack Compose for UI and coroutines for asynchronous operations.

```kotlin
class CardFormViewModel : ViewModel() {
    var cardForm: CardForm? = null

    init {
        setupCardForm()
    }

    private fun setupCardForm() {
        cardForm = CardFormBuilder()
            .setCardNumberField { state ->
                println("Card Number Field State: $state")
            }
            .setCVVField { state ->
                println("CVV Field State: $state")
            }
            .setCardHolderNameField { state ->
                println("Card Holder Name Field State: $state")
            }
            .setExpireMonthField { state ->
                println("Expire Month Field State: $state")
            }
            .setExpireYearField { state ->
                println("Expire Year Field State: $state")
            }
            .setCardBrandChangeListener { brand ->
                println("Card Brand Changed: $brand")
            }
            .build()
    }

    fun handlePayment(intentId: String) {
        viewModelScope.launch {
            try {
                val cardData = cardForm?.collect()
                if (cardData == null) {
                    println("Failed to collect card data.")
                    return@launch
                }

                val intentDetails = cardForm?.pay(
                    intentId = intentId,
                    cardData = cardData,
                    saveCard = true, // Set to true to save the card (optional)
                    billingData = mapOf("address" to "123 Main St", "city" to "New York"), // Optional
                    shippingData = mapOf("address" to "456 Elm St", "city" to "Boston")   // Optional
                )

                println("Payment Successful: $intentDetails")
            } catch (e: Exception) {
                println("Payment Error: ${e.message}")
            }
        }
    }
}

class CardFormActivity : ComponentActivity() {
    private val viewModel: CardFormViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            CardFormScreen(viewModel = viewModel)
        }
    }
}

@Composable
fun CardFormScreen(viewModel: CardFormViewModel) {
    val coroutineScope = rememberCoroutineScope()

    Scaffold(
        topBar = {
            TopAppBar(title = { Text("Payment Form") })
        },
        content = {
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(16.dp),
                verticalArrangement = Arrangement.spacedBy(16.dp)
            ) {
                SecureTextField(
                    cardForm = viewModel.cardForm!!,
                    type = FieldType.CARD_HOLDER_NAME,
                    placeholder = { Text("Cardholder Name") }
                )

                SecureTextField(
                    cardForm = viewModel.cardForm!!,
                    type = FieldType.CARD_NUMBER,
                    placeholder = { Text("Card Number") }
                )

                Row(
                    modifier = Modifier.fillMaxWidth(),
                    horizontalArrangement = Arrangement.spacedBy(8.dp)
                ) {
                    SecureTextField(
                        cardForm = viewModel.cardForm!!,
                        type = FieldType.EXPIRE_MONTH,
                        placeholder = { Text("MM") },
                        modifier = Modifier.weight(1f)
                    )

                    SecureTextField(
                        cardForm = viewModel.cardForm!!,
                        type = FieldType.EXPIRE_YEAR,
                        placeholder = { Text("YY") },
                        modifier = Modifier.weight(1f)
                    )

                    SecureTextField(
                        cardForm = viewModel.cardForm!!,
                        type = FieldType.CVV,
                        placeholder = { Text("CVV") },
                        modifier = Modifier.weight(1f)
                    )
                }

                Button(
                    onClick = {
                        viewModel.handlePayment("<intent_id>")
                    },
                    modifier = Modifier.fillMaxWidth()
                ) {
                    Text("Pay")
                }
            }
        }
    )
}

```

--------------------------------

### Regular Customer Payload Example

Source: https://docs.moneyhash.io/docs/customers-1

Example JSON payload for registering a regular customer. Includes fields like first name, last name, email, and phone number.

```JSON
{
  "first_name": "test",
  "last_name": "customer",
  "email": "customer@test.com",
  "phone_number": "+201234567891",
  "description": "test description"
}
```

--------------------------------

### Company Customer Payload Example

Source: https://docs.moneyhash.io/docs/customers-1

Example JSON payload for registering a company customer. Includes company-specific fields like company name, contact person, tax ID, and tax rate.

```JSON
{
  "type": "COMPANY",
  "company_name": "test company name",
  "contact_person_name": "test contact person name",
  "tax_id": 0,
  "tax_rate": 0,
  "email": "customer@test.com",
  "phone_number": "+201234567891",
  "description": "test description"
}
```

--------------------------------

### Initialize MoneyHash SDK

Source: https://docs.moneyhash.io/docs/pay-using-card-information-3

Initializes the MoneyHashSDK instance using the account's Public API Key. This must be performed before accessing any SDK functionality.

```kotlin
val moneyHashSDK = MoneyHashSDKBuilder()
    .setPublicKey("<account_public_api_key>")
    .build()
```

--------------------------------

### Update Payment Method (PHP)

Source: https://docs.moneyhash.io/docs/update-selected-method-2

This PHP example illustrates how to update a payment method for a payment intent using cURL. It sets up the request URL, headers, and includes an example of the data payload.

```php
<?php

function updatePaymentMethod($intentId, $paymentMethodData) {
    $url = "https://web.moneyhash.io/api/v1.4/external/payments/intents/{$intentId}/update-method/";
    
    $headers = [
        'Content-Type: application/json',
        'Accept: application/json'
    ];

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($paymentMethodData));
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

    $response = curl_exec($ch);
    
    if (curl_errno($ch)) {
        echo 'Curl error: ' . curl_error($ch);
        curl_close($ch);
        return false;
    }

    curl_close($ch);
    return json_decode($response, true);
}

// Example usage:
// $intentId = 'your_intent_id';
// $paymentMethodData = [
//     'payment_method' => 'card',
//     'reset_intent' => false,
//     'method_id' => 'pm_12345',
//     'partial_wallet' => false
// ];
// $result = updatePaymentMethod($intentId, $paymentMethodData);
// print_r($result);

?>

```
Tokens:
Raw