@opexa/portal-sdk NPM

Opexa Portal SDK

A library that provides a set of functions to interact with Opexa Portal API.

Installation

npm install @opexa/portal-sdk

Usage

Create sdk instance

// lib/sdk.js
import Sdk from '@opexa/portal-sdk';

export const sdk = new Sdk({
  platform: 'Z892',
  environment: 'development',
});

Use sdk instance

import { sdk } from '$lib/sdk';
import * as React from 'react';

function Page() {
  const [account, setAccount] = React.useState();

  React.useEffect(function () {
    sdk.account().then(setAccount);
  }, []);

  return (
    <pre>
      <code>{JSON.stringify(account, null, 2)}</code>
    </pre>
  );
}

API

`Sdk`

Sdk accepts the following options:

*site - The site ID to be used
*sitePlatform - The site platform ID to be used
*platform - The platform code to be used
*environment - Whether to use production/development api

, and returns the following methods:

signIn - Start user session

signIn(input: SignInInput): Promise<SignInReturn>

type SignInInput =
  | {
      type: 'NAME_AND_PASSWORD';
      name: string;
      password: string;
    }
  | {
      type: 'MOBILE_NUMBER';
      mobileNumber: string;
      verificationCode: string;
    };

type SignInReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'AccountNotFound';
            message: string;
          };
    };

signOut - End current user session
```
signOut(): Promise<void>
```

site - Retrieve site details

site(): Promise<SiteReturn>

interface Site {
  id: string;
  name: string;
  logo?: string;
}

type SiteReturn =
  | {
      ok: true;
      data: Site;
    }
  | {
      ok: false;
      error: HttpError;
    };

platform - Retrieve current platform details

platform(): Promise<PlatformReturn>

interface Platform {
  paymentSettings: {
    minimumFirstDepositAmount?: number;
    restrictWithdrawalsToVerifiedMembers: boolean;
    depositGateway: {
      bank: GatewaySettings;
      gcash: GatewaySettings;
      maya: GatewaySettings;
      mayaApp: GatewaySettings;
    };
    withdrawalGateway: {
      bank: GatewaySettings;
      gcash: GatewaySettings;
      maya: GatewaySettings;
      mayaApp: GatewaySettings;
    };
  };
  pointsClubSettings: {
    multiplier: number;
  };
}

type PlatformReturn =
  | {
      ok: true;
      data: Platform;
    }
  | {
      ok: false;
      error: HttpError;
    };

account - Retrieve current user's details

account(): Promise<AccountReturn>

interface Account {
  id: string;
  name: string;
  status: MemberAccountStatus;
  realName?: string;
  nickName?: string;
  dateOfBirth?: Date;
  validId?: string;
  emailAddress?: string;
  mobileNumber?: string;
  verified: boolean;
  verificationStatus: MemberAccountVerificationStatus;
  mobileNumberVerified: boolean;
  mobileNumberVerificationRequired: boolean;
  transactionPassword: boolean;
  dateTimeLastActive?: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type AccountReturn =
  | {
      ok: true;
      data: Account;
    }
  | {
      ok: false;
      error: HttpError;
    };

createAccount - Create new user account

createAccount(input: CreateAccountInput): Promise<CreateAccountReturn>

interface CreateAccountInput {
  id?: string;
  name: string;
  password: string;
  mobileNumber: string;
  dateOfBirth: string;
  btag?: string;
  domain?: string;
  referralCode?: string;
  verificationCode?: string;
  reCAPTCHAResponse?: string;
}

type CreateAccountReturn =
  | {
      ok: true;
      error?: never;
      data: {
        id: string;
      };
    }
  | {
      ok: false;
      data?: never;
      error:
        | HttpError
        | {
            name:
              | 'AccountNameNotAvailableError'
              | 'InvalidPlatformError'
              | 'InvalidReCAPTCHAResponseError'
              | 'InvalidSMSVerificationCodeError'
              | 'MinimumAgeRequirementError'
              | 'MobileNumberNotAvailableError';
            message: string;
          };
    };

updateAccount - Update current user's details

updateAccount(input: UpdateAccountInput): Promise<UpdateAccountReturn>

type UpdateAccountReturn =
  | {
      ok: true;
      data?: never;
      error?: never;
    }
  | {
      ok: false;
      data?: never;
      error: {
        name:
          | 'AccountNameNotAvailableError'
          | 'EmailAddressNotAvailableError'
          | 'InvalidTransactionPasswordError'
          | 'MobileNumberNotAvailableError'
          | 'NickNameNotAvailableError'
          | 'RealNameAlreadySetError'
          | 'ValidIdAlreadySetError';
        message: string;
      };
    };

deleteAccount - Delete current user's account

deleteAccount(id: string): Promise<DeleteAccountReturn>

type DeleteAccountReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error: UnknownError | HttpError;
    };

resetPassword - Reset user's password

resetPassword(input: ResetPasswordInput): Promise<ResetPasswordReturn>

interface ResetPasswordInput {
  mobileNumber: string;
  newPassword: string;
  verificationCode: string;
}

type ResetPasswordReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'AccountNotFoundError' | 'InvalidVerificationCodeError';
            message: string;
          };
    };

verificationDetails - Retrieve user's verification details

verificationDetails(): Promise<VerificationDetailsReturn>

interface VerificationDetails {
  id: string;
  status: MemberVerificationStatus;
  address: string;
  sourceOfIncome: string;
  natureOfWork: string;
  nationality: string;
  placeOfBirth: string;
  idFrontImage: File;
  selfieImage: File;
}

type VerificationDetailsReturn =
  | {
      ok: true;
      data: VerificationDetails;
    }
  | {
      ok: false;
      error: HttpError;
    };

submitVerificationDetails - Submit current user's verification details

submitVerificationDetails(input: SubmitVerificationDetailsInput): Promise<SubmitVerificationDetailsReturn>

interface SubmitVerificationDetailsInput {
  id?: string;
  idFrontImage: string;
  selfieImage: string;
  address: string;
  sourceOfIncome: string;
  natureOfWork: string;
  nationality: string;
  placeOfBirth: string;
}

type SubmitVerificationDetailsReturn =
  | {
      ok: true;
      data: {
        id: string;
      };
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name:
              | 'FileDoesNotExistError'
              | 'FileNotReadyError'
              | 'MemberVerificationAlreadyExistsError';
            message: string;
          };
    };

updateVerificationDetails - Update current user's verification details

updateVerificationDetails(input: UpdateVerificationDetailsInput): Promise<UpdateVerificationDetailsReturn>

interface UpdateVerificationDetailsInput {
  idFrontImage: string;
  selfieImage: string;
  address: string;
  permanentAddress: string;
  sourceOfIncome: string;
  natureOfWork: string;
  nationality: string;
  placeOfBirth: string;
}

type UpdateVerificationDetailsReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name:
              | 'FileDoesNotExistError'
              | 'FileNotReadyError'
              | 'MemberVerificationAlreadyApprovedError'
              | 'MemberVerificationDoesNotExistError';
            message: string;
          };
    };

verifyMobileNumber - Verify current user's mobile number

verifyMobileNumber(verificationCode: string): Promise<VerifyMobileNumberReturn>

type VerifyMobileNumberReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'InvalidSMSVerificationCodeError' | 'MobileNumberAlreadyVerifiedError';
            message: string;
          };
    };

profileCompletion - Retrieve current user's profile completion status

profileCompletion(): Promise<ProfileCompletionReturn>

interface ProfileCompletion {
  completionPercentage: number;
  personalInformation: boolean;
  accountVerification: boolean;
  mobileNumberVerification: boolean;
  transactionPassword: boolean;
  accountPassword: boolean;
}

type ProfileCompletionReturn =
  | {
      ok: true;
      data: ProfileCompletion;
    }
  | {
      ok: false;
      error: HttpError;
    };

sendVerificationCode - Send verification code to mobile number or email address

sendVerificationCode(mobileNumber: string): Promise<SendVerificationCodeReturn>

type SendVerificationCodeReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'InvalidPlatformError' | 'NotReadyToSendVerficationCodeError';
            message: string;
          };
    };

wallet - Retrieve current user's wallet details

wallet(): Promise<WalletReturn>

interface Wallet {
  id: string;
  balance: number;
  currency: Currency;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type WalletReturn =
  | {
      ok: true;
      data: Wallet | null;
    }
  | {
      ok: false;
      error: HttpError;
    };

announcements - Retrieve announcements for current platform

announcements(input?: AnnouncementsInput): Promise<AnnouncementsReturn>

interface AnnouncementsInput {
  first?: number;
  after?: string;
}

interface Announcement {
  id: string;
  type: 'RELEASE' | 'SCHEDULED_MAINTENANCE';
  title: string;
  status: 'ACTIVE' | 'INACTIVE';
  message: string;
  activationStartDateTime: Date;
  activationEndDateTime: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type AnnouncementsReturn =
  | {
      ok: true;
      data: {
        announcements: (Announcement & { cursor: string })[];
        totalCount: number;
        hasNextPage: boolean;
        endCursor?: string;
      };
    }
  | {
      ok: false;
      error: HttpError;
    };

createWithdrawal - Create new withdrawal request

createWithdrawal(input: CreateWithdrawalInput): Promise<CreateWithdrawalReturn>

interface CreateBankWithdrawalInput {
  id?: string;
  type: 'BANK';
  amount: number;
  transactionPassword: string;
}

interface CreateGCashWithdrawalInput {
  id?: string;
  type: 'GCASH';
  amount: number;
  transactionPassword: string;
  recipientMobileNumber: string;
}

interface CreateMayaWithdrawalInput {
  id?: string;
  type: 'MAYA';
  amount: number;
  transactionPassword: string;
  recipientMobileNumber: string;
}

interface CreateMayaAppWithdrawalInput {
  id?: string;
  type: 'MAYA_APP';
  amount: number;
  transactionPassword: string;
}

type CreateWithdrawalInput =
  | CreateBankWithdrawalInput
  | CreateGCashWithdrawalInput
  | CreateMayaWithdrawalInput
  | CreateMayaAppWithdrawalInput;

type CreateWithdrawalReturn =
  | {
      ok: true;
      data: {
        id: string;
      };
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name:
              | 'MobileNumberNotVerifiedError'
              | 'AccountNotVerifiedError'
              | 'InvalidWithdrawalAmountError'
              | 'WithdrawalDailyLimitExceededError'
              | 'InvalidTransactionPasswordError'
              | 'NotEnoughBalanceError';
            message: string;
          };
    };

withdrawalRecords - Retrieve current user's withdrawal records

withdrawalRecords(input?: WithdrawalRecordsInput): Promise<WithdrawalRecordsReturn>

type WithdrawalRecordType = 'MANUAL' | 'BANK' | 'GCASH' | 'MAYA';
type WithdrawalRecordStatus = 'PENDING' | 'APPROVED' | 'REJECTED' | 'CONFIRMED' | 'CANCELLED';

interface WithdrawalRecordsInput {
  first?: number;
  after?: string;
  filter?: {
    type?: {
      equal?: WithdrawalRecordType;
      notEqual?: WithdrawalRecordType;
      in?: WithdrawalRecordType[];
      notIn?: WithdrawalRecordType[];
    };
    status?: {
      equal?: WithdrawalRecordStatus;
      notEqual?: WithdrawalRecordStatus;
      in?: WithdrawalRecordStatus[];
      notIn?: WithdrawalRecordStatus[];
    };
    reference?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    withdrawalNumber?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    dateTimeCreated?: {
      equal?: Date | string;
      notEqual?: Date | string;
      in?: Date | string[];
      notIn?: Date | string[];
      lesserThan?: Date | string;
      lesserThanOrEqual?: Date | string;
      greaterThan?: Date | string;
      greaterThanOrEqual?: Date | string;
    };
    dateTimeLastUpdated?: {
      equal?: Date | string;
      notEqual?: Date | string;
      in?: Date | string[];
      notIn?: Date | string[];
      lesserThan?: Date | string;
      lesserThanOrEqual?: Date | string;
      greaterThan?: Date | string;
      greaterThanOrEqual?: Date | string;
    };
  };
}

interface WithdrawalRecord {
  id: string;
  type: WithdrawalRecordType;
  bank?: 'AUBKPHMM' | 'MBTCPHMM' | 'BNORPHMM' | 'MKRUPHM1';
  fee: number;
  amount: number;
  netAmount: number;
  status: WithdrawalRecordStatus;
  reference?: string;
  withdrawalNumber: string;
  recipientMobileNumber?: string;
  dateTimeConfirmed?: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type WithdrawalRecordsReturn =
  | {
      ok: true;
      data: {
        withdrawalRecords: (WithdrawalRecord & { cursor: string })[];
        totalCount: number;
        hasNextPage: boolean;
        endCursor?: string;
      };
    }
  | {
      ok: false;
      error: HttpError;
    };

remainingDailyWithdrawalsCount - Retrieve current user's remaining daily withdrawals count

remainingDailyWithdrawalsCount(): Promise<RemainingDailyWithdrawalsCountReturn>

type RemainingDailyWithdrawalsCountReturn =
  | {
      ok: true;
      data: number;
    }
  | {
      ok: false;
      error: HttpError;
    };

createDeposit - Create new deposit request

createDeposit(input: CreateDepositInput): Promise<CreateDepositReturn>

interface CreateMayaDepositInput {
  id?: string;
  type: 'MAYA';
  amount: number;
  promo?: string;
}

interface CreateGCashDepositInput {
  id?: string;
  type: 'GCASH';
  amount: number;
  promo?: string;
}

interface CreateMayaAppDepositInput {
  id?: string;
  type: 'MAYA_APP';
  amount: number;
  promo?: string;
}

type CreateDepositInput =
  | CreateMayaDepositInput
  | CreateGCashDepositInput
  | CreateMayaAppDepositInput;

type CreateDepositReturn =
  | {
      ok: true;
      data: {
        id: string;
      };
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name:
              | 'DepositPromoMaximumAmountExceededError'
              | 'DepositPromoMinimumAmountNotMetError'
              | 'HasActiveBonusError'
              | 'MaximumDepositAmountExceededError'
              | 'MinimumDepositAmountNotMetError'
              | 'MinimumFirstDepositAmountNotMetError'
              | 'PromoNotEnabledError'
              | 'WalletDoesNotExistError';
            message: string;
          };
    };

deposit - Retrieve deposit details

deposit(id: string): Promise<DepositReturn>

interface Deposit {
  id: string;
  type: 'BANK' | 'GCASH' | 'MANUAL' | 'MAYA' | 'MAYA_APP';
  status: 'PENDING' | 'ACCEPTED' | 'APPROVED' | 'REJECTED' | 'CONFIRMED' | 'CANCELLED';
  amount: number;
  netAmount: number;
  fee: number;
  reference?: string;
  checkoutUrl?: string;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type DepositReturn =
  | {
      ok: true;
      data: Deposit | null;
    }
  | {
      ok: false;
      error: HttpError;
    };

depositRecords - Retrieve current user's deposit records

depositRecords(input?: DepositRecordsInput): Promise<DepositRecordsReturn>

type DepositRecordType = 'BANK' | 'GCASH' | 'MANUAL' | 'MAYA' | 'MAYA_APP';
type DepositRecordStatus =
  | 'PENDING'
  | 'ACCEPTED'
  | 'APPROVED'
  | 'REJECTED'
  | 'CONFIRMED'
  | 'CANCELLED';

interface DepositRecordsInput {
  first?: number;
  after?: string;
  filter?: {
    type?: {
      equal?: DepositRecordType;
      notEqual?: DepositRecordType;
      in?: DepositRecordType[];
      notIn?: DepositRecordType[];
    };
    status?: {
      equal?: DepositRecordStatus;
      notEqual?: DepositRecordStatus;
      in?: DepositRecordStatus[];
      notIn?: DepositRecordStatus[];
    };
    reference?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    depositNumber?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    dateTimeCreated?: {
      equal?: Date | string;
      notEqual?: Date | string;
      in?: Date | string[];
      notIn?: Date | string[];
      lesserThan?: Date | string;
      lesserThanOrEqual?: Date | string;
      greaterThan?: Date | string;
      greaterThanOrEqual?: Date | string;
    };
    dateTimeLastUpdated?: {
      equal?: Date | string;
      notEqual?: Date | string;
      in?: Date | string[];
      notIn?: Date | string[];
      lesserThan?: Date | string;
      lesserThanOrEqual?: Date | string;
      greaterThan?: Date | string;
      greaterThanOrEqual?: Date | string;
    };
  };
}

interface DepositRecord {
  id: string;
  type: DepositRecordType;
  status: DepositRecordStatus;
  amount: number;
  netAmount: number;
  fee: number;
  reference?: string;
  depositNumber: string;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type DepositRecordsReturn =
  | {
      ok: true;
      data: {
        depositRecords: (DepositRecord & { cursor: string })[];
        totalCount: number;
        hasNextPage: boolean;
        endCursor?: string;
      };
    }
  | {
      ok: false;
      error: HttpError;
    };

depositsCount - Retrieve current user's deposits count

depositsCount(): Promise<DepositsCountReturn>

type DepositsCountReturn =
  | {
      ok: true;
      data: number;
    }
  | {
      ok: false;
      error: HttpError;
    };

betRecords - Retrieve current user's bet records

betRecords(input?: BetRecordsInput): Promise<BetRecordsReturn>

type BetRecordStatus = 'STARTED' | 'SETTLED' | 'CANCELLED';

interface BetRecordsInput {
  first?: number;
  after?: string;
  sort?: SortOrder;
  filter?: {
    serialCode?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    game?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
    };
    game__externalId?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    game__type?: {
      equal?: GameType;
      notEqual?: GameType;
      in?: GameType[];
      notIn?: GameType[];
    };
    game__provider?: {
      equal?: GameProvider;
      notEqual?: GameProvider;
      in?: GameProvider[];
      notIn?: GameProvider[];
    };
    dateTimeCreated?: {
      equal?: Date | string;
      notEqual?: Date | string;
      in?: Date | string[];
      notIn?: Date | string[];
      lesserThan?: Date | string;
      lesserThanOrEqual?: Date | string;
      greaterThan?: Date | string;
      greaterThanOrEqual?: Date | string;
    };
    vendorRoundId?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    status?: {
      equal?: BetRecordStatus;
      notEqual?: BetRecordStatus;
      in?: BetRecordStatus[];
      notIn?: BetRecordStatus[];
    };
  };
  startDateTime?: {
    equal?: Date | string;
    notEqual?: Date | string;
    in?: Date | string[];
    notIn?: Date | string[];
    lesserThan?: Date | string;
    lesserThanOrEqual?: Date | string;
    greaterThan?: Date | string;
    greaterThanOrEqual?: Date | string;
  };
  endDateTime?: {
    equal?: Date | string;
    notEqual?: Date | string;
    in?: Date | string[];
    notIn?: Date | string[];
    lesserThan?: Date | string;
    lesserThanOrEqual?: Date | string;
    greaterThan?: Date | string;
    greaterThanOrEqual?: Date | string;
  };
}

interface BetRecord {
  id: string;
  game: Game;
  status: BetRecordStatus;
  serialCode: string;
  vendorRoundId?: string;
  bet: number;
  payout: number;
  validBet: number;
  jackpotContribution: number;
  jackpotPayout: number;
  winloss?: number;
  betContent?: string;
  contestName?: string;
  externalCategory?: string;
  dateTimeSettled?: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
  metadata: {
    odds?: string;
    validBet?: number;
  };
}

type BetRecordsReturn =
  | {
      ok: true;
      data: {
        betRecords: (BetRecord & { cursor: string })[];
        totalCount: number;
        hasNextPage: boolean;
        endCursor?: string;
      };
    }
  | {
      ok: false;
      error: HttpError;
    };

transactionRecords - Retrieve current user's transaction records

transactionRecords(input?: TransactionRecordsInput): Promise<TransactionRecordsReturn>

type TransactionRecordType =
  | 'DEPOSIT'
  | 'PAYOUT'
  | 'WITHDRAWAL_REFUND'
  | 'TRANSFER_IN'
  | 'WITHDRAWAL'
  | 'BET'
  | 'TRANSFER_OUT'
  | 'ROLLBACK'
  | 'BET_REFUND'
  | 'PAYOUT_REFUND'
  | 'CASHBACK_BONUS'
  | 'BONUS'
  | 'RESERVE'
  | 'REJECT_WITHDRAWAL'
  | 'MANUAL_DEPOSIT'
  | 'GCASH_DEPOSIT'
  | 'MANUAL_WITHDRAWAL'
  | 'BANK_WITHDRAWAL'
  | 'GCASH_WITHDRAWAL'
  | 'COMMIT_RESERVE'
  | 'ROLLBACK_PAYOUT'
  | 'ROLLBACK_RESERVE';

interface TransactionRecordsInput {
  first?: number;
  after?: string;
  filter?: {
    type?: {
      equal?: TransactionRecordType;
      notEqual?: TransactionRecordType;
      in?: TransactionRecordType[];
      notIn?: TransactionRecordType[];
    };
    referenceNumber?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    dateTimeCreated?: {
      equal?: Date | string;
      notEqual?: Date | string;
      in?: Date | string[];
      notIn?: Date | string[];
      lesserThan?: Date | string;
      lesserThanOrEqual?: Date | string;
      greaterThan?: Date | string;
      greaterThanOrEqual?: Date | string;
    };
  };
}

interface TransactionRecord {
  id: string;
  type: TransactionRecordType;
  amount: number;
  content?: string;
  currentBalance: number;
  referenceNumber: string;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type TransactionRecordsReturn =
  | {
      ok: true;
      data: {
        transactionRecords: (TransactionRecord & { cursor: string })[];
        totalCount: number;
        hasNextPage: boolean;
        endCursor?: string;
      };
    }
  | {
      ok: false;
      error: HttpError;
    };

promos - Retrieve promos for current platform

promos(): Promise<PromosReturn>

interface Promo {
  id: string;
  type: 'DEPOSIT';
  name: string;
  banner: {
    id: string;
    url: string;
    status: 'READY';
    dateTimeCreated: Date;
  };
  status: 'ACTIVE' | 'INACTIVE' | 'DISABLED' | 'EXPIRED';
  description: string;
  minimumBonusAmount?: number;
  maximumBonusAmount?: number;
  minimumDepositAmount?: number;
  maximumDepositAmount?: number;
  activationStartDateTime: Date;
  activationEndDateTime: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type PromosReturn =
  | {
      ok: true;
      data: Promo[];
    }
  | {
      ok: false;
      error: HttpError;
    };

availablePromos - Retrieve available promos for current user
```
availablePromos(): Promise<PromosReturn>
```

bonus - Retrieve current user's bonus details

bonus(): Promise<BonusReturn>

interface Bonus {
  id: string;
  promo: Promo;
  deposit?: {
    type: DepositRecordType;
    status: DepositRecordStatus;
    amount: number;
    netAmount: number;
    fee: number;
    reference?: string;
    dateTimeCreated: Date;
    dateTimeLastUpdated: Date;
  };
  amount: number;
  balance: number;
  turnoverRequirement: number;
  currentTurnoverRequirementContribution: number;
  currentTurnoverRequirementContributionPercentage: number;
  expiration: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type BonusReturn =
  | {
      ok: true;
      data: Bonus | null;
    }
  | {
      ok: false;
      error: HttpError;
    };

cashbacks - Retrieve cashbacks for current platform

cashbacks(): Promise<CashbackReturn>

interface Cashback {
  id: string;
  name: string;
  banner: {
    id: string;
    url: string;
    status: 'READY';
    dateTimeCreated: Date;
  };
  status: CashbackStatus;
  description: string;
  activationStartDateTime: Date;
  activationEndDateTime: Date;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type CashbackReturn =
  | {
      ok: true;
      data: Cashback[];
    }
  | {
      ok: false;
      error: HttpError;
    };

cashbackBonuses - Retrieve current user's cashback bonuses

cashbackBonuses(): Promise<CashbackBonusesReturn>

interface CashbackBonus {
  id: string;
  balance: number;
  cashback: Cashback;
  dateTimeCreated: Date;
  dateTimeLastUpdated: Date;
}

type CashbackBonusesReturn =
  | {
      ok: true;
      data: CashbackBonus[];
    }
  | {
      ok: false;
      error: HttpError;
    };

claimCashbackBonus - Claim cashback bonus

claimCashbackBonus(id: string): Promise<ClaimCashbackBonusReturn>

type ClaimCashbackBonusReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'CashbackBonusDoesNotExistError';
            message: string;
          };
    };

games - Retrieve games

games(input?: GamesInput): Promise<GamesReturn>

type GameType = 'SLOTS' | 'SPORTS' | 'BINGO' | 'FISHING' | 'LIVE' | 'GAMES';
type GameProvider =
  | 'JILI'
  | 'PGSOFT'
  | 'FACHAI'
  | 'PLAYTECH'
  | 'CQ9'
  | 'JDB'
  | 'BOOONGO'
  | 'HABANERO'
  | 'RELAXGAMING'
  | 'DG'
  | 'E2E'
  | 'BTI'
  | 'DARWIN'
  | 'MEGABALL'
  | 'DRBINGO'
  | 'RTG';

interface GamesInput {
  after?: string;
  first?: number;
  filter?: {
    id?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
    };
    name?: {
      equal?: string;
      notEqual?: string;
      in?: string[];
      notIn?: string[];
      contains?: string;
      startsWith?: string;
    };
    type?: {
      equal?: GameType;
      notEqual?: GameType;
      in?: GameType[];
      notIn?: GameType[];
    };
    provider?: {
      equal?: GameProvider;
      notEqual?: GameProvider;
      in?: GameProvider[];
      notIn?: GameProvider[];
    };
  };
}

interface Game {
  id: string;
  type: GameType;
  name: string;
  image: string;
  provider: GameProvider;
}

type GamesReturn =
  | {
      ok: true;
      data: {
        games: (Game & { cursor: string })[];
        totalCount: number;
        hasNextPage: boolean;
        endCursor?: string;
      };
    }
  | {
      ok: false;
      error: HttpError;
    };

gameSession - Retrieve game session details

gameSession(id: string): Promise<GameSessionReturn>

type GameSession =
  | {
      id: string;
      game: Game;
      status: 'READY';
      launchUrl: string;
      dateTimeCreated: Date;
      dateTimeLastUpdated: Date;
    }
  | {
      id: string;
      game: Game;
      status: 'PENDING' | 'STARTING' | 'ENDED' | 'CANCELLED';
      dateTimeCreated: Date;
      dateTimeLastUpdated: Date;
    };

type GameSessionReturn =
  | {
      ok: true;
      data: GameSession | null;
    }
  | {
      ok: false;
      error: HttpError;
    };

createGameSession - Create new game session

createGameSession(input:CreateGameSessionInput): Promise<CreateGameSessionReturn>

interface CreateGameSessionInput {
  id?: string;
  game: string;
}

type CreateGameSessionReturn =
  | {
      ok: true;
      data: {
        id: string;
      };
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'GameDoesNotExistError';
            message: string;
          };
    };

endGameSession - End game session

endGameSession(id: string): Promise<EndGameSessionReturn>

type EndGameSessionReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error: HttpError | UnknownError;
    };

file - Retrieve file details

file(id: string): Promise<FileReturn>

type File =
  | {
      id: string;
      url?: never;
      status: 'UPLOADING' | 'FAILED';
      dateTimeCreated: Date;
    }
  | {
      id: string;
      url: string;
      status: 'READY';
      dateTimeCreated: Date;
    }
  | {
      id: string;
      url?: string;
      status: 'DELETED';
      dateTimeCreated: Date;
    };

type FileReturn =
  | {
      ok: true;
      data: File | null;
    }
  | {
      ok: false;
      error: HttpError;
    };

uploadImageFile - Upload image file

uploadImageFile(input: globalThis.File): Promise<UploadImageFileReturn>

type UploadImageFileReturn =
  | {
      ok: true;
      data: {
        id: string;
      };
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'FileFormatNotSupportedError' | 'FileNameTooLongError' | 'FileSizeTooBigError';
            message: string;
          };
    };

pointsWallet - Retrieve current user's points wallet details

pointsWallet(): Promise<PointsWalletReturn>

interface PointsWallet {
  id: string;
  points: number;
  account: string;
  dateTimeCreated: Date;
}

type PointsWalletReturn =
  | {
      ok: true;
      data: PointsWallet | null;
    }
  | {
      ok: false;
      error: HttpError;
    };

pointsToCashConversion - Convert points to cash

pointsToCashConversion(amount: number): Promise<PointsToCashConversionReturn>

type PointsToCashConversionReturn =
  | {
      ok: true;
    }
  | {
      ok: false;
      error:
        | HttpError
        | {
            name: 'InsufficientPointsError';
            message: string;
          };
    };

8 months ago

8 months ago

8 months ago

8 months ago

8 months ago