@opexa/portal-components 0.0.957 → 0.0.959

package/dist/lib/services/report.d.ts

@@ -0,0 +1,243 @@
+import type { SimplifyDeep } from 'type-fest';
+import type { _Jackpot, ActivityRecord, ActivityRecordType, BetRecord, BetRecordStatus, BooleanFilterField, DateFilterField, DepositRecord, DepositStatus, DepositType, EnumFilterField, GameProvider, GameType, Jackpot, JackpotCursor, JackpotPayout, JackpotPayoutCursor, JackpotStatus, JackpotType, NumberFilterField, ObjectIdFilterField, PaginatedQuery, PointsWalletTransaction, PointsWalletTransactionType, Referral, ReferralCommission, SortOrder, SpotBonusPromo, StringFilterField, Tournament, TournamentStatus, TournamentType, TransactionRecord, TransactionType, WithdrawalRecord, WithdrawalStatus, WithdrawalType } from '../types';
+import { type GraphQLRequestOptions } from './graphqlRequest';
+export type BetRecordsInput = SimplifyDeep<BetRecordsQueryVariables>;
+export interface BetRecordsQuery {
+    member: PaginatedQuery<'betRecords', BetRecord>;
+}
+export interface BetRecordsQueryVariables {
+    first?: number;
+    after?: string;
+    sort?: SortOrder;
+    filter?: {
+        game__type?: EnumFilterField<GameType>;
+        game__provider?: EnumFilterField<GameProvider>;
+        serialCode?: StringFilterField;
+        dateTimeCreated?: DateFilterField;
+        vendorRoundId?: StringFilterField;
+        status?: EnumFilterField<BetRecordStatus>;
+    };
+    startDateTime?: DateFilterField;
+    endDateTime?: DateFilterField;
+}
+export declare const getBetRecords: (input?: BetRecordsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<BetRecord>>;
+export interface TransactionRecordsQuery {
+    member: PaginatedQuery<'transactionRecords', TransactionRecord>;
+}
+export interface TransactionRecordsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        referenceNumber?: StringFilterField;
+        type?: EnumFilterField<TransactionType>;
+        dateTimeCreated?: DateFilterField;
+    };
+}
+export type TransactionRecordsInput = SimplifyDeep<TransactionRecordsQueryVariables>;
+export declare const getTransactionRecords: (input?: TransactionRecordsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<TransactionRecord>>;
+export interface WithdrawalRecordsQuery {
+    member: PaginatedQuery<'withdrawalRecords', WithdrawalRecord>;
+}
+export interface WithdrawalRecordsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        id?: ObjectIdFilterField;
+        type?: EnumFilterField<WithdrawalType>;
+        status?: EnumFilterField<WithdrawalStatus>;
+        reference?: StringFilterField;
+        withdrawal?: ObjectIdFilterField;
+        withdrawalNumber?: StringFilterField;
+        dateTimeCreated?: DateFilterField;
+        dateTimeLastUpdated?: DateFilterField;
+    };
+}
+export type WithdrawalRecordsInput = SimplifyDeep<WithdrawalRecordsQueryVariables>;
+export declare const getWithdrawalRecords: (input?: WithdrawalRecordsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<WithdrawalRecord>>;
+export interface DepositRecordsQuery {
+    member: PaginatedQuery<'depositRecords', DepositRecord>;
+}
+export interface DepositRecordsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        id?: ObjectIdFilterField;
+        type?: EnumFilterField<DepositType>;
+        status?: EnumFilterField<DepositStatus>;
+        deposit?: ObjectIdFilterField;
+        depositNumber?: StringFilterField;
+        reference?: StringFilterField;
+        dateTimeCreated?: DateFilterField;
+        dateTimeLastUpdated?: DateFilterField;
+    };
+}
+export type DepositRecordsInput = SimplifyDeep<DepositRecordsQueryVariables>;
+export declare const getDepositRecords: (input?: DepositRecordsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<DepositRecord>>;
+export interface DepositsCountQuery {
+    member: {
+        depositsCount: number;
+    };
+}
+export declare const getDepositsCount: (options?: GraphQLRequestOptions) => Promise<number>;
+export interface PointsWalletTransactionsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        type?: EnumFilterField<PointsWalletTransactionType>;
+    };
+}
+export interface PointsWalletTransactionsQuery {
+    member: PaginatedQuery<'pointsWalletTransactions', PointsWalletTransaction>;
+}
+export type PointsWalletTransactionsInput = SimplifyDeep<PointsWalletTransactionsQueryVariables>;
+export declare const getPointsWalletTransactions: (input?: PointsWalletTransactionsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<PointsWalletTransaction>>;
+export interface ActivityRecordsQuery {
+    member: PaginatedQuery<'activityRecords', ActivityRecord>;
+}
+export interface ActivityRecordsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        type?: EnumFilterField<ActivityRecordType>;
+        dateTimeCreated?: DateFilterField;
+    };
+}
+export type ActivityRecordsInput = SimplifyDeep<ActivityRecordsQueryVariables>;
+export declare const getActivityRecords: (input?: ActivityRecordsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<ActivityRecord>>;
+export interface ReferralsQuery {
+    member: PaginatedQuery<'referrals', Referral>;
+}
+export interface ReferralsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        level?: NumberFilterField;
+        upline?: ObjectIdFilterField;
+        downline?: ObjectIdFilterField;
+    };
+}
+export type ReferralsInput = SimplifyDeep<ReferralsQueryVariables>;
+export declare const getReferrals: (input?: ReferralsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<Referral>>;
+export interface ReferralCommissionQuery {
+    member: {
+        referralCommission?: ReferralCommission | null;
+    };
+}
+export declare const getReferralCommission: (options?: GraphQLRequestOptions) => Promise<ReferralCommission | null>;
+export interface UplinesByNameQuery {
+    uplinesByName: Referral[];
+}
+export interface UplinesByNameQueryVariables {
+    search: string;
+    first?: number;
+}
+export type UplinesByNameInput = SimplifyDeep<UplinesByNameQueryVariables>;
+export declare const getUplinesByName: (input?: UplinesByNameInput, options?: GraphQLRequestOptions) => Promise<Referral[]>;
+export interface DownlinesByNameQueryVariables {
+    search: string;
+    first?: number;
+}
+export interface DownlinesByNameQuery {
+    downlinesByName: Referral[];
+}
+export type DownlinesByNameInput = SimplifyDeep<DownlinesByNameQueryVariables>;
+export declare const getDownlinesByName: (input?: DownlinesByNameInput, options?: GraphQLRequestOptions) => Promise<Referral[]>;
+export interface PromoByCodeQueryVariables {
+    code: string;
+}
+export interface PromoByCodeQuery {
+    promoByCode: SpotBonusPromo;
+}
+export declare const getPromoByCode: (code: string, options?: GraphQLRequestOptions) => Promise<SpotBonusPromo>;
+export interface JackpotsQuery extends PaginatedQuery<'jackpots', Jackpot> {
+}
+export interface _JackpotsQuery extends PaginatedQuery<'_jackpots', _Jackpot> {
+}
+export interface JackpotsQueryVariables {
+    after?: string;
+    first?: number;
+    filter?: {
+        id?: ObjectIdFilterField;
+        name?: StringFilterField;
+        status?: EnumFilterField<JackpotStatus>;
+        drawing?: BooleanFilterField;
+        deleted?: BooleanFilterField;
+    };
+    sort?: {
+        order: SortOrder;
+        cursor: JackpotCursor;
+    };
+}
+export interface _JackpotsQueryVariables {
+    after?: string;
+    first?: number;
+    filter?: {
+        id?: ObjectIdFilterField;
+        name?: StringFilterField;
+        status?: EnumFilterField<JackpotStatus>;
+        type?: EnumFilterField<JackpotType>;
+        deleted?: BooleanFilterField;
+        paused?: BooleanFilterField;
+    };
+    sort?: {
+        order: SortOrder;
+        cursor: JackpotCursor;
+    };
+}
+export type JackpotsInput = SimplifyDeep<JackpotsQueryVariables>;
+export type _JackpotsInput = SimplifyDeep<_JackpotsQueryVariables>;
+export declare const getJackpots: (input?: JackpotsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<Jackpot>>;
+export declare const getJackpotsNext: (input?: _JackpotsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<_Jackpot>>;
+export interface JackpotsCountQuery {
+    jackpots: {
+        totalCount: number;
+    };
+}
+export interface JackpotsCountQueryVariables {
+    filter?: JackpotsQueryVariables['filter'];
+}
+export type JackpotsCountInput = SimplifyDeep<JackpotsCountQueryVariables>;
+export declare const getJackpotsCount: (input?: JackpotsCountInput, options?: GraphQLRequestOptions) => Promise<number>;
+export interface JackpotPayoutsQuery extends PaginatedQuery<'jackpotPayouts', JackpotPayout> {
+}
+export interface JackpotPayoutsQueryVariables {
+    after?: string;
+    first?: number;
+    filter?: {
+        id?: ObjectIdFilterField;
+        member?: ObjectIdFilterField;
+        jackpot?: ObjectIdFilterField;
+        dateTimeCreated?: DateFilterField;
+    };
+    sort?: {
+        order: SortOrder;
+        cursor: JackpotPayoutCursor;
+    };
+}
+export type JackpotPayoutsInput = SimplifyDeep<JackpotPayoutsQueryVariables>;
+export declare const getJackpotPayouts: (input?: JackpotPayoutsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<JackpotPayout>>;
+export interface TournamentsQuery extends PaginatedQuery<'tournaments', Tournament> {
+}
+export interface TournamentsQueryVariables {
+    after?: string;
+    first?: number;
+    filter?: {
+        id?: ObjectIdFilterField;
+        type?: EnumFilterField<TournamentType>;
+        status?: EnumFilterField<TournamentStatus>;
+        activationStartDateTime?: DateFilterField;
+        activationEndDateTime?: DateFilterField;
+    };
+}
+export type TournamentsInput = SimplifyDeep<TournamentsQueryVariables>;
+export declare const getTournaments: (input?: TournamentsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<Tournament>>;
+export interface TournamentsCountQuery {
+    tournaments: {
+        totalCount: number;
+    };
+}
+export interface TournamentsCountQueryVariables {
+    filter?: TournamentsQueryVariables['filter'];
+}
+export type TournamentsCountInput = SimplifyDeep<TournamentsCountQueryVariables>;
+export declare const getTournamentsCount: (input?: TournamentsCountInput, options?: GraphQLRequestOptions) => Promise<number>;

package/dist/lib/services/report.js

@@ -0,0 +1,124 @@
+import { cache } from 'react';
+import { REPORT_GRAPHQL_ENDPOINT } from '../constants/index.js';
+import { graphqlRequest } from './graphqlRequest.js';
+import { ACTIVITY_RECORDS, BET_RECORDS, DEPOSIT_RECORDS, DEPOSITS_COUNT, DOWNLINES_BY_NAME, JACKPOT_PAYOUTS, JACKPOTS, JACKPOTS_COUNT, JACKPOTS_NEXT, POINTS_WALLET_TRANSACTIONS, PROMO_BY_CODE, REFERRAL_COMMISSION, REFERRALS, TOURNAMENTS, TOURNAMENTS_COUNT, TRANSACTION_RECORDS, UPLINES_BY_NAME, WITHDRAWAL_RECORDS, } from './queries.js';
+export const getBetRecords = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, BET_RECORDS, input, options);
+    return res.member.betRecords;
+});
+export const getTransactionRecords = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, TRANSACTION_RECORDS, input, options);
+    return res.member.transactionRecords;
+});
+export const getWithdrawalRecords = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, WITHDRAWAL_RECORDS, input, options);
+    return res.member.withdrawalRecords;
+});
+export const getDepositRecords = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, DEPOSIT_RECORDS, input, options);
+    return res.member.depositRecords;
+});
+export const getDepositsCount = cache(async (options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, DEPOSITS_COUNT, undefined, options);
+    return res.member.depositsCount;
+});
+export const getPointsWalletTransactions = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, POINTS_WALLET_TRANSACTIONS, input, options);
+    return res.member.pointsWalletTransactions;
+});
+export const getActivityRecords = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, ACTIVITY_RECORDS, input, options);
+    return res.member.activityRecords;
+});
+export const getReferrals = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, REFERRALS, input, options);
+    return res.member.referrals;
+});
+export const getReferralCommission = cache(async (options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, REFERRAL_COMMISSION, undefined, options);
+    return res.member.referralCommission ?? null;
+});
+export const getUplinesByName = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, UPLINES_BY_NAME, input, options);
+    return res.uplinesByName;
+});
+export const getDownlinesByName = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, DOWNLINES_BY_NAME, input, options);
+    return res.downlinesByName;
+});
+export const getPromoByCode = cache(async (code, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, PROMO_BY_CODE, { code }, options);
+    return res.promoByCode;
+});
+export const getJackpots = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, JACKPOTS, input, {
+        cache: 'force-cache',
+        ...options,
+        next: {
+            tags: ['jackpots', JSON.stringify(input)],
+            revalidate: 60,
+            ...options?.next,
+        },
+    });
+    return res.jackpots;
+});
+export const getJackpotsNext = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, JACKPOTS_NEXT, input, {
+        cache: 'force-cache',
+        ...options,
+        next: {
+            tags: ['jackpots', JSON.stringify(input)],
+            revalidate: 60,
+            ...options?.next,
+        },
+    });
+    return res._jackpots;
+});
+export const getJackpotsCount = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, JACKPOTS_COUNT, input, {
+        cache: 'force-cache',
+        ...options,
+        next: {
+            tags: ['jackpotsCount', JSON.stringify(input)],
+            revalidate: 60,
+            ...options?.next,
+        },
+    });
+    return res.jackpots.totalCount ?? 0;
+});
+export const getJackpotPayouts = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, JACKPOT_PAYOUTS, input, {
+        cache: 'force-cache',
+        ...options,
+        next: {
+            tags: ['jackpotPayouts', JSON.stringify(input)],
+            revalidate: 60,
+            ...options?.next,
+        },
+    });
+    return res.jackpotPayouts;
+});
+export const getTournaments = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, TOURNAMENTS, input, {
+        cache: 'force-cache',
+        ...options,
+        next: {
+            tags: ['tournaments', JSON.stringify(input)],
+            revalidate: 60,
+            ...options?.next,
+        },
+    });
+    return res.tournaments;
+});
+export const getTournamentsCount = cache(async (input, options) => {
+    const res = await graphqlRequest(REPORT_GRAPHQL_ENDPOINT, TOURNAMENTS_COUNT, input, {
+        cache: 'force-cache',
+        ...options,
+        next: {
+            tags: ['tournamentsCount', JSON.stringify(input)],
+            revalidate: 60,
+            ...options?.next,
+        },
+    });
+    return res.tournaments.totalCount ?? 0;
+});

package/dist/lib/services/sha256.d.ts

@@ -0,0 +1,4 @@
+declare global {
+    var EdgeRuntime: string | undefined;
+}
+export declare function sha256(input: string): Promise<string>;

package/dist/lib/services/sha256.js

@@ -0,0 +1,16 @@
+export async function sha256(input) {
+    /*
+     * crypto and other node apis are not available in edge runtime
+     * ref: https://vercel.com/docs/functions/runtimes/edge#check-if-you're-running-on-the-edge-runtime
+     */
+    if (typeof EdgeRuntime === 'string') {
+        throw new Error("Cannot use 'sha256' in edge runtime");
+    }
+    if (typeof window === 'undefined') {
+        const crypto = await import('crypto');
+        return crypto.createHash('sha256').update(input).digest('hex');
+    }
+    return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(input))))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}

package/dist/lib/services/trigger.d.ts

@@ -0,0 +1,94 @@
+import type { Simplify, SimplifyDeep } from 'type-fest';
+import type { BooleanFilterField, FCMDeviceType, Message, PaginatedQuery, Quest } from '../types';
+import { type GraphQLRequestOptions } from './graphqlRequest';
+export interface MessagesQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        popup?: BooleanFilterField;
+        markedAsRead?: BooleanFilterField;
+    };
+}
+export interface MessagesQuery extends PaginatedQuery<'messages', Message> {
+}
+export interface MessagesInput extends SimplifyDeep<MessagesQueryVariables> {
+}
+export declare const getMessages: (input?: MessagesInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<Message>>;
+export interface UnreadMessagesCountQuery {
+    messages: {
+        totalCount: number;
+    };
+}
+export interface UnreadMessagesCountQueryVariables {
+    filter?: {
+        popup?: BooleanFilterField;
+    };
+}
+export type UnreadMessagesCountInput = SimplifyDeep<UnreadMessagesCountQueryVariables>;
+export declare const getUnreadMessagesCount: (input?: UnreadMessagesCountInput, options?: GraphQLRequestOptions) => Promise<number>;
+export interface MarkMessageAsReadMutationVariables {
+    id: string;
+}
+export interface MarkMessageAsReadMutation {
+    markMessageAsRead: boolean;
+}
+export declare const markMessageAsRead: (id: string, options?: GraphQLRequestOptions) => Promise<void>;
+export interface MarkAllMessagesAsReadMutation {
+    markAllMessagesAsRead: boolean;
+}
+export declare const markAllMessagesAsRead: (options?: GraphQLRequestOptions) => Promise<void>;
+export interface ClaimRewardMutationVariables {
+    id: string;
+}
+export type ClaimRewardError = {
+    name: 'RewardAlreadyClaimedError';
+    message: string;
+} | {
+    name: 'RewardAlreadyExpiredError';
+    message: string;
+};
+export interface ClaimRewardMutation {
+    claimReward?: null | ClaimRewardError;
+}
+export declare const claimReward: (id: string, options?: GraphQLRequestOptions) => Promise<void>;
+export interface AvailableQuestsQuery {
+    availableQuests: Quest[];
+}
+export declare const getAvailableQuests: (options?: GraphQLRequestOptions) => Promise<Quest[]>;
+export interface AvailableQuestsIdsQuery {
+    availableQuests: {
+        id: string;
+    }[];
+}
+export declare const getAvailableQuestsCount: (options?: GraphQLRequestOptions) => Promise<number>;
+export interface CheckInDailyCheckInQuestMutation {
+    checkInDailyCheckInQuest: boolean;
+}
+export interface CheckInDailyCheckInQuestMutationVariables {
+    input: {
+        id: string;
+    };
+}
+export declare const checkInDailyCheckInQuest: (id: string, options?: GraphQLRequestOptions) => Promise<void>;
+export interface RegisterFCMDeviceMutationVariables {
+    input: {
+        type: FCMDeviceType;
+        token: string;
+    };
+}
+export interface RegisterFCMDeviceMutation {
+    registerFCMDevice: boolean;
+}
+export type RegisterFCMDeviceInput = Simplify<RegisterFCMDeviceMutationVariables['input']>;
+export declare const registerFCMDevice: (input: RegisterFCMDeviceInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface UnregisterFCMDeviceMutationVariables {
+    input: {
+        type: Array<FCMDeviceType>;
+        token?: string;
+    };
+}
+export interface UnregisterFCMDeviceMutation {
+    unregisterFCMDevice: boolean;
+}
+export type UnregisterFCMDeviceInput = Simplify<UnregisterFCMDeviceMutationVariables['input']>;
+export declare const unregisterFCMDevice: (input: UnregisterFCMDeviceInput, options?: GraphQLRequestOptions) => Promise<void>;

package/dist/lib/services/trigger.js

@@ -0,0 +1,92 @@
+import { cache } from 'react';
+import { TRIGGER_GRAPHQL_ENDPOINT } from '../constants/index.js';
+import { graphqlRequest } from './graphqlRequest.js';
+import { AVAILABLE_QUEST_IDS, AVAILABLE_QUESTS, CHECK_IN_DAILY_QUEST, CLAIM_REWARD, MARK_ALL_MESSAGES_AS_READ, MARK_MESSAGE_AS_READ, MESSAGES, REGISTER_FCM_DEVICE, UNREAD_MESSAGES_COUNT, UNREGISTER_FCM_DEVICE, } from './queries.js';
+export const getMessages = cache(async (input, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, MESSAGES, input, options);
+    return res.messages;
+});
+export const getUnreadMessagesCount = cache(async (input, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, UNREAD_MESSAGES_COUNT, {
+        ...input,
+        filter: {
+            ...input?.filter,
+            markedAsRead: {
+                equal: false,
+            },
+        },
+    }, options);
+    return res.messages.totalCount ?? 0;
+});
+export const markMessageAsRead = async (id, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, MARK_MESSAGE_AS_READ, { id }, options);
+    if (!res.markMessageAsRead) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong.';
+        Error.captureStackTrace?.(error, markMessageAsRead);
+        throw error;
+    }
+};
+export const markAllMessagesAsRead = async (options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, MARK_ALL_MESSAGES_AS_READ, undefined, options);
+    if (!res.markAllMessagesAsRead) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong.';
+        Error.captureStackTrace?.(error, markAllMessagesAsRead);
+        throw error;
+    }
+};
+export const claimReward = async (id, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, CLAIM_REWARD, { id }, options);
+    if (res.claimReward) {
+        const error = new Error();
+        error.name = res.claimReward.name;
+        error.message = ERROR_CODES_MESSAGE_MAP[res.claimReward.name];
+        Error.captureStackTrace?.(error, claimReward);
+        throw error;
+    }
+};
+export const getAvailableQuests = cache(async (options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, AVAILABLE_QUESTS, undefined, options);
+    return res.availableQuests;
+});
+export const getAvailableQuestsCount = cache(async (options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, AVAILABLE_QUEST_IDS, undefined, options);
+    return res.availableQuests.length ?? 0;
+});
+export const checkInDailyCheckInQuest = async (id, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, CHECK_IN_DAILY_QUEST, { input: { id } }, options);
+    if (!res.checkInDailyCheckInQuest) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong.';
+        Error.captureStackTrace?.(error, checkInDailyCheckInQuest);
+        throw error;
+    }
+};
+export const registerFCMDevice = async (input, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, REGISTER_FCM_DEVICE, { input }, options);
+    if (!res.registerFCMDevice) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong.';
+        Error.captureStackTrace?.(error, registerFCMDevice);
+        throw error;
+    }
+};
+export const unregisterFCMDevice = async (input, options) => {
+    const res = await graphqlRequest(TRIGGER_GRAPHQL_ENDPOINT, UNREGISTER_FCM_DEVICE, { input }, options);
+    if (!res.unregisterFCMDevice) {
+        const error = new Error();
+        error.name = 'UnknownError';
+        error.message = 'Something went wrong.';
+        Error.captureStackTrace?.(error, unregisterFCMDevice);
+        throw error;
+    }
+};
+const ERROR_CODES_MESSAGE_MAP = {
+    RewardAlreadyExpiredError: 'Reward is either expired or no longer available',
+    RewardAlreadyClaimedError: 'Reward is already claimed',
+};