import Shika Creators, { Shika CreatorsError } from '@shikacreators/node'

const shikacreators = new Shika Creators('sk_test_...')

try {
  const payment = await shikacreators.payments.create({
    amount: 5000,
    currency: 'GHS',
    payment_method: 'mobile_money',
    phone: '0241234567'
  })
} catch (error) {
  if (error instanceof Shika CreatorsError) {
    switch (error.type) {
      case 'authentication_error':
        console.error('Check your API key')
        break

      case 'invalid_request_error':
        console.error(`Invalid parameter: ${error.param}`)
        break

      case 'payment_error':
        switch (error.code) {
          case 'insufficient_funds':
            // Tell customer to top up
            break
          case 'phone_unreachable':
            // Tell customer to check their phone
            break
          default:
            console.error(error.message)
        }
        break

      case 'rate_limit_error':
        // Wait and retry
        await sleep(60000)
        break

      case 'api_error':
        // Log and alert
        console.error('Shika Creators server error:', error.message)
        break
    }
  } else {
    // Network error or other
    console.error('Unexpected error:', error)
  }
}

import shikacreators
from shikacreators.errors import (
    Shika CreatorsError,
    AuthenticationError,
    InvalidRequestError,
    PaymentError,
    RateLimitError,
    APIError
)

client = shikacreators.Client('sk_test_...')

try:
    payment = client.payments.create(
        amount=5000,
        currency='GHS',
        payment_method='mobile_money',
        phone='0241234567'
    )
except AuthenticationError as e:
    print('Check your API key')

except InvalidRequestError as e:
    print(f'Invalid parameter: {e.param}')

except PaymentError as e:
    if e.code == 'insufficient_funds':
        print('Please top up your account')
    elif e.code == 'phone_unreachable':
        print('Please check your phone')
    else:
        print(e.message)

except RateLimitError:
    import time
    time.sleep(60)
    # Retry

except APIError as e:
    print(f'Shika Creators server error: {e.message}')

except Shika CreatorsError as e:
    print(f'Error: {e.message}')

use Shika Creators\Shika Creators;
use Shika Creators\Exception\Shika CreatorsException;
use Shika Creators\Exception\AuthenticationException;
use Shika Creators\Exception\InvalidRequestException;
use Shika Creators\Exception\PaymentException;
use Shika Creators\Exception\RateLimitException;
use Shika Creators\Exception\ApiException;

$shikacreators = new Shika Creators('sk_test_...');

try {
    $payment = $shikacreators->payments->create([
        'amount' => 5000,
        'currency' => 'GHS',
        'payment_method' => 'mobile_money',
        'phone' => '0241234567'
    ]);
} catch (AuthenticationException $e) {
    echo 'Check your API key';

} catch (InvalidRequestException $e) {
    echo 'Invalid parameter: ' . $e->getParam();

} catch (PaymentException $e) {
    switch ($e->getCode()) {
        case 'insufficient_funds':
            echo 'Please top up your account';
            break;
        case 'phone_unreachable':
            echo 'Please check your phone';
            break;
        default:
            echo $e->getMessage();
    }

} catch (RateLimitException $e) {
    sleep(60);
    // Retry

} catch (ApiException $e) {
    error_log('Shika Creators server error: ' . $e->getMessage());

} catch (Shika CreatorsException $e) {
    echo 'Error: ' . $e->getMessage();
}