@opexa/portal-components 0.0.83 → 0.0.85

package/dist/server/utils/prefetchProfileCompletionQuery.js

@@ -1,5 +1,4 @@
-import { getProfileCompletion } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getProfileCompletion } from '../../services/index.js';
 import { getProfileCompletionQueryKey, getQueryClient } from '../../utils/index.js';
 import { getSession } from '../services/getSession.js';
 export const prefetchProfileCompletionQuery = async () => {
@@ -11,9 +10,7 @@ export const prefetchProfileCompletionQuery = async () => {
         queryFn: async ({ signal }) => {
             return await getProfileCompletion({
                 signal,
-                environment: ENVIRONMENT,
                 headers: {
-                    'Platform-Code': PLATFORM_CODE,
                     Authorization: `Bearer ${session.token}`,
                 },
             });

package/dist/server/utils/prefetchPromoQuery.js

@@ -1,20 +1,11 @@
-import { getPromos } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getPromo } from '../../services/index.js';
 import { getPromoQueryKey, getQueryClient } from '../../utils/index.js';
 export const prefetchPromoQuery = async (id) => {
     await getQueryClient().prefetchQuery({
         queryKey: getPromoQueryKey(id),
         queryFn: async ({ signal }) => {
-            /* FIXME: use getPromo query once api is fixed */
-            const promos = await getPromos({
-                signal,
-                environment: ENVIRONMENT,
-                headers: {
-                    'Platform-Code': PLATFORM_CODE,
-                },
-            });
-            const promo = promos.find((p) => p.id === id) ?? null;
-            return promo;
+            const promo = await getPromo(id, { signal });
+            return promo ?? null;
         },
     });
 };

package/dist/server/utils/prefetchPromosQuery.js

@@ -1,17 +1,10 @@
-import { getPromos } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getPromos } from '../../services/index.js';
 import { getPromosQueryKey, getQueryClient } from '../../utils/index.js';
 export const prefetchPromosQuery = async () => {
     await getQueryClient().prefetchQuery({
         queryKey: getPromosQueryKey(),
         queryFn: async ({ signal }) => {
-            return await getPromos({
-                signal,
-                environment: ENVIRONMENT,
-                headers: {
-                    'Platform-Code': PLATFORM_CODE,
-                },
-            });
+            return await getPromos({ signal });
         },
     });
 };

package/dist/server/utils/prefetchTopWinsQuery.js

@@ -1,17 +1,10 @@
-import { getTopWins } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getTopWins } from '../../services/index.js';
 import { getQueryClient, getTopWinsQueryKey } from '../../utils/index.js';
 export const prefetchTopWinsQuery = async () => {
     await getQueryClient().prefetchQuery({
         queryKey: getTopWinsQueryKey(),
         queryFn: async ({ signal }) => {
-            return await getTopWins({
-                signal,
-                environment: ENVIRONMENT,
-                headers: {
-                    'Platform-Code': PLATFORM_CODE,
-                },
-            });
+            return await getTopWins({ signal });
         },
     });
 };

package/dist/server/utils/prefetchTournamentsQuery.d.ts

@@ -1,2 +1,2 @@
-import { type TournamentsInput } from '@opexa/portal-sdk-core';
+import { type TournamentsInput } from '../../services';
 export declare const prefetchTournamentsQuery: (input?: TournamentsInput) => Promise<void>;

package/dist/server/utils/prefetchTournamentsQuery.js

@@ -1,17 +1,10 @@
-import { getTournaments } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getTournaments } from '../../services/index.js';
 import { getQueryClient, getTournamentsQueryKey } from '../../utils/index.js';
 export const prefetchTournamentsQuery = async (input) => {
     await getQueryClient().prefetchInfiniteQuery({
         queryKey: getTournamentsQueryKey(input),
         queryFn: async ({ signal }) => {
-            return await getTournaments(input, {
-                signal,
-                environment: ENVIRONMENT,
-                headers: {
-                    'Platform-Code': PLATFORM_CODE,
-                },
-            });
+            return await getTournaments(input, { signal });
         },
         initialPageParam: undefined,
     });

package/dist/server/utils/prefetchTransactionRecordsQuery.d.ts

@@ -1,2 +1,2 @@
-import { type TransactionRecordsInput } from '@opexa/portal-sdk-core';
+import { type TransactionRecordsInput } from '../../services';
 export declare const prefetchTransactionRecordsQuery: (input?: TransactionRecordsInput) => Promise<void>;

package/dist/server/utils/prefetchTransactionRecordsQuery.js

@@ -1,5 +1,4 @@
-import { getTransactionRecords, } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getTransactionRecords, } from '../../services/index.js';
 import { getQueryClient, getTransactionRecordsQueryKey } from '../../utils/index.js';
 import { getSession } from '../services/getSession.js';
 export const prefetchTransactionRecordsQuery = async (input) => {
@@ -11,9 +10,7 @@ export const prefetchTransactionRecordsQuery = async (input) => {
         queryFn: async ({ signal }) => {
             return await getTransactionRecords(input, {
                 signal,
-                environment: ENVIRONMENT,
                 headers: {
-                    'Platform-Code': PLATFORM_CODE,
                     Authorization: `Bearer ${session.token}`,
                 },
             });

package/dist/server/utils/prefetchUnreadMessagesCountQuery.d.ts

@@ -1,2 +1,2 @@
-import { type UnreadMessagesCountInput } from '@opexa/portal-sdk-core';
+import { type UnreadMessagesCountInput } from '../../services';
 export declare const prefetchUnreadMessagesCountQuery: (input?: UnreadMessagesCountInput) => Promise<void>;

package/dist/server/utils/prefetchUnreadMessagesCountQuery.js

@@ -1,5 +1,4 @@
-import { getUnreadMessagesCount, } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getUnreadMessagesCount, } from '../../services/index.js';
 import { getAccountQueryKey, getQueryClient } from '../../utils/index.js';
 import { getSession } from '../services/getSession.js';
 export const prefetchUnreadMessagesCountQuery = async (input) => {
@@ -11,9 +10,7 @@ export const prefetchUnreadMessagesCountQuery = async (input) => {
         queryFn: async ({ signal }) => {
             return await getUnreadMessagesCount(input, {
                 signal,
-                environment: ENVIRONMENT,
                 headers: {
-                    'Platform-Code': PLATFORM_CODE,
                     Authorization: `Bearer ${session.token}`,
                 },
             });

package/dist/server/utils/prefetchWalletQuery.js

@@ -1,5 +1,4 @@
-import { getWallet } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getWallet } from '../../services/index.js';
 import { getQueryClient, getWalletQueryKey } from '../../utils/index.js';
 import { getSession } from '../services/getSession.js';
 export const prefetchWalletQuery = async () => {
@@ -9,14 +8,13 @@ export const prefetchWalletQuery = async () => {
     await getQueryClient().prefetchQuery({
         queryKey: getWalletQueryKey(),
         queryFn: async ({ signal }) => {
-            return await getWallet({
+            const wallet = await getWallet({
                 signal,
-                environment: ENVIRONMENT,
                 headers: {
-                    'Platform-Code': PLATFORM_CODE,
                     Authorization: `Bearer ${session.token}`,
                 },
             });
+            return wallet ?? null;
         },
     });
 };

package/dist/server/utils/prefetchWithdrawalRecordsQuery.d.ts

@@ -1,2 +1,2 @@
-import { type WithdrawalRecordsInput } from '@opexa/portal-sdk-core';
+import { type WithdrawalRecordsInput } from '../../services';
 export declare const prefetchWithdrawalRecordsQuery: (input?: WithdrawalRecordsInput) => Promise<void>;

package/dist/server/utils/prefetchWithdrawalRecordsQuery.js

@@ -1,5 +1,4 @@
-import { getWithdrawalRecords, } from '@opexa/portal-sdk-core';
-import { ENVIRONMENT, PLATFORM_CODE } from '../../constants/index.js';
+import { getWithdrawalRecords, } from '../../services/index.js';
 import { getQueryClient, getWithdrawalRecordsQueryKey } from '../../utils/index.js';
 import { getSession } from '../services/getSession.js';
 export const prefetchWithdrawalRecordsQuery = async (input) => {
@@ -11,9 +10,7 @@ export const prefetchWithdrawalRecordsQuery = async (input) => {
         queryFn: async ({ signal }) => {
             return await getWithdrawalRecords(input, {
                 signal,
-                environment: ENVIRONMENT,
                 headers: {
-                    'Platform-Code': PLATFORM_CODE,
                     Authorization: `Bearer ${session.token}`,
                 },
             });

package/dist/services/ObjectId.d.ts

@@ -0,0 +1,24 @@
+export declare class ObjectId {
+    private _buffer;
+    constructor(buffer: Buffer);
+    static translate(id: ObjectId, type: number): ObjectId;
+    static generate(type?: number): ObjectId;
+    static generateFromKey(type: number, key: string): Promise<ObjectId>;
+    static from(value: string | Buffer): ObjectId;
+    get type(): number;
+    get buffer(): Buffer<ArrayBufferLike>;
+    compare(other: ObjectId): 0 | 1 | -1;
+    equals(other: ObjectId): boolean;
+    clone(): ObjectId;
+    toString(encoding?: 'bs58' | 'hex' | 'base64'): string;
+}
+export declare const ObjectType: {
+    MemberAccount: number;
+    MemberVerification: number;
+    Deposit: number;
+    Withdrawal: number;
+    File: number;
+    Game: number;
+    GameSession: number;
+    MayaSession: number;
+};

package/dist/services/ObjectId.js

@@ -0,0 +1,86 @@
+import bs58 from 'bs58';
+import { sha256 } from 'crypto-hash';
+import randomBytes from 'randombytes';
+const MACHINE_ID = randomBytes(5);
+let counter = randomBytes(4).readUInt32BE(0) & 0xffffff;
+export class ObjectId {
+    _buffer;
+    constructor(buffer) {
+        this._buffer = buffer;
+    }
+    static translate(id, type) {
+        const buffer = Buffer.from(id.buffer);
+        buffer[0] = type & 0xff;
+        return ObjectId.from(buffer);
+    }
+    static generate(type) {
+        const buffer = Buffer.alloc(13);
+        const time = Math.floor(Date.now() / 1000) & 0xffffffff;
+        counter = (counter + 1) & 0xffffff;
+        buffer[0] = (type ?? 0) & 0xff;
+        buffer[1] = (time >> 24) & 0xff;
+        buffer[2] = (time >> 16) & 0xff;
+        buffer[3] = (time >> 8) & 0xff;
+        buffer[4] = time & 0xff;
+        buffer[5] = MACHINE_ID[0];
+        buffer[6] = MACHINE_ID[1];
+        buffer[7] = MACHINE_ID[2];
+        buffer[8] = MACHINE_ID[3];
+        buffer[9] = MACHINE_ID[4];
+        buffer[10] = (counter >> 16) & 0xff;
+        buffer[11] = (counter >> 8) & 0xff;
+        buffer[12] = counter & 0xff;
+        return new ObjectId(buffer);
+    }
+    static async generateFromKey(type, key) {
+        const buffer = Buffer.alloc(13);
+        buffer[0] = type & 0xff;
+        Buffer.from(await sha256(key, { outputFormat: 'buffer' })).copy(buffer, 1, 0, 12);
+        return new ObjectId(buffer);
+    }
+    static from(value) {
+        if (typeof value === 'string') {
+            if (value.length > 20) {
+                throw new Error('String value exceeds the limit of 20 characters');
+            }
+            return new ObjectId(Buffer.from(bs58.decode(value)));
+        }
+        if (value instanceof Buffer) {
+            return new ObjectId(value);
+        }
+        throw new Error('Invalid value type. Expected string or Buffer.');
+    }
+    get type() {
+        return this.buffer[0];
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    compare(other) {
+        return this._buffer.compare(other._buffer);
+    }
+    equals(other) {
+        return this._buffer.equals(other._buffer);
+    }
+    clone() {
+        const buffer = Buffer.alloc(13);
+        this.buffer.copy(buffer);
+        return ObjectId.from(buffer);
+    }
+    toString(encoding) {
+        if (!encoding || encoding === 'bs58') {
+            return bs58.encode(this._buffer);
+        }
+        return this._buffer.toString(encoding);
+    }
+}
+export const ObjectType = {
+    MemberAccount: 8,
+    MemberVerification: 15,
+    Deposit: 9,
+    Withdrawal: 14,
+    File: 16,
+    Game: 203,
+    GameSession: 204,
+    MayaSession: 230,
+};

package/dist/services/account.service.d.ts

@@ -0,0 +1,341 @@
+import type { Simplify, SimplifyDeep } from 'type-fest';
+import type { Announcement, AnnouncementType, AnnouncementVisibility, DateFilterField, EnumFilterField, MemberAccount, MemberVerification, PaginatedQuery, PaymentSettings, PointsClubSettings, ProfileCompletion, SecretQuestion } from '../types';
+import { type GraphQLRequestOptions } from './graphqlRequest';
+export interface MemberAccountQuery {
+    memberAccount: MemberAccount;
+}
+export declare const getMemberAccount: (options?: GraphQLRequestOptions) => Promise<MemberAccount>;
+export type RegisterMemberAccountError = {
+    name: 'AccountNameNotAvailableError';
+    message: string;
+} | {
+    name: 'InvalidPlatformError';
+    message: string;
+} | {
+    name: 'InvalidReCAPTCHAResponseError';
+    message: string;
+} | {
+    name: 'InvalidSMSVerificationCodeError';
+    message: string;
+} | {
+    name: 'MinimumAgeRequirementError';
+    message: string;
+} | {
+    name: 'MobileNumberNotAvailableError';
+    message: string;
+} | {
+    name: 'ReCAPTCHAVerificationFailedError';
+    message: string;
+};
+export interface RegisterMemberAccountMutation {
+    registerMemberAccount?: null | RegisterMemberAccountError;
+}
+export interface RegisterMemberAccountMutationVariables {
+    input: {
+        id: string;
+        name: string;
+        password: string;
+        mobileNumber: string;
+        birthDay: string;
+        domain?: string;
+        btag?: string;
+    };
+    referralCode?: string;
+    verificationCode?: string;
+}
+export type RegisterMemberAccountInput = Simplify<RegisterMemberAccountMutationVariables['input'] & Pick<RegisterMemberAccountMutationVariables, 'referralCode' | 'verificationCode'>>;
+export declare const registerMemberAccount: (input: RegisterMemberAccountInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface RegisterMemberAccountViaMobileMutation {
+    registerMemberAccountViaMobile?: null | RegisterMemberAccountError;
+}
+export interface RegisterMemberAccountViaMobileMutationVariables {
+    input: {
+        id: string;
+        mobileNumber: string;
+        domain?: string;
+        btag?: string;
+    };
+    referralCode?: string;
+    verificationCode?: string;
+}
+export type RegisterMemberAccountViaMobileInput = Simplify<RegisterMemberAccountViaMobileMutationVariables['input'] & Pick<RegisterMemberAccountViaMobileMutationVariables, 'verificationCode' | 'referralCode'>>;
+export declare const registerMemberAccountViaMobile: (input: RegisterMemberAccountViaMobileInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface RegisterMemberAccountByMobileNumberMutationVariables {
+    input: {
+        id: string;
+        mobileNumber: string;
+        password: string;
+        realName: string;
+    };
+    mobileNumberVerificationCode: string;
+}
+export type RegisterMemberAccountByMobileNumberError = {
+    name: 'MobileNumberNotAvailableError';
+    message: string;
+} | {
+    name: 'InvalidSMSVerificationCodeError';
+    message: string;
+} | {
+    name: 'InvalidPlatformError';
+    message: string;
+};
+export interface RegisterMemberAccountByMobileNumberMutation {
+    registerMemberAccountByMobileNumber?: null | RegisterMemberAccountByMobileNumberError;
+}
+export type RegisterMemberAccountByMobileNumberInput = Simplify<RegisterMemberAccountByMobileNumberMutationVariables['input'] & Pick<RegisterMemberAccountByMobileNumberMutationVariables, 'mobileNumberVerificationCode'>>;
+export declare const registerMemberAccountByMobileNumber: (input: RegisterMemberAccountByMobileNumberInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface RegisterMemberAccountMutationVariables__Next {
+    input: {
+        id: string;
+        name: string;
+        password: string;
+        mobileNumber?: string;
+        domain?: string;
+        btag?: string;
+    };
+}
+export type RegisterMemberAccountInput__Next = Simplify<RegisterMemberAccountMutationVariables__Next['input']>;
+export declare const registerMemberAccount__next: (input: RegisterMemberAccountInput__Next, options?: GraphQLRequestOptions) => Promise<void>;
+export type RegisterMemberAccountByNameError = {
+    name: 'AccountNameNotAvailableError';
+    message: string;
+} | {
+    name: 'InvalidPlatformError';
+    message: string;
+} | {
+    name: 'InvalidReCAPTCHAResponseError';
+    message: string;
+};
+export interface RegisterMemberAccountByNameMutationVariables {
+    input: {
+        id: string;
+        name: string;
+        password: string;
+    };
+}
+export interface RegisterMemberAccountByNameMutation {
+    registerMemberAccountByName?: null | RegisterMemberAccountByNameError;
+}
+export type RegisterMemberAccountByNameInput = Simplify<RegisterMemberAccountByNameMutationVariables['input']>;
+export declare const registerMemberAccountByName: (input: RegisterMemberAccountByNameInput, options?: GraphQLRequestOptions) => Promise<void>;
+export type UpdateMemberAccountError = {
+    name: 'AccountNameNotAvailableError';
+    message: string;
+} | {
+    name: 'EmailAddressNotAvailableError';
+    message: string;
+} | {
+    name: 'InvalidTransactionPasswordError';
+    message: string;
+} | {
+    name: 'MobileNumberNotAvailableError';
+    message: string;
+} | {
+    name: 'NickNameNotAvailableError';
+    message: string;
+} | {
+    name: 'RealNameAlreadySetError';
+    message: string;
+} | {
+    name: 'ValidIdAlreadySetError';
+    message: string;
+};
+export interface UpdateMemberAccountMutation {
+    updateMemberAccount?: null | UpdateMemberAccountError;
+}
+export interface UpdateMemberAccountMutationVariables {
+    input: {
+        id: string;
+        data: {
+            name?: string;
+            password?: string;
+            emailAddress?: string;
+            mobileNumber?: string;
+            realName?: string;
+            nickName?: string;
+            transactionPassword?: string;
+            validId?: string;
+            mobileNumberVerificationRequired?: boolean;
+            secretQuestion?: SecretQuestion;
+            secretAnswer?: string;
+            birthDay?: string;
+            branchCode?: string;
+        };
+    };
+}
+export type UpdateMemberAccountDataInput = Simplify<UpdateMemberAccountMutationVariables['input']['data']>;
+export declare const updateMemberAccount: (id: string, data: UpdateMemberAccountDataInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface DeleteMemberAccountMutation {
+    deleteMemberAccount: boolean;
+}
+export interface DeleteMemberAccountMutationVariables {
+    input: {
+        id: string;
+    };
+}
+export declare const deleteMemberAccount: (id: string, options?: GraphQLRequestOptions) => Promise<void>;
+export type ResetPasswordError = {
+    name: 'AccountNotFoundError';
+    message: string;
+} | {
+    name: 'InvalidVerificationCodeError';
+    message: string;
+};
+export interface ResetPasswordMutation {
+    resetPassword?: null | ResetPasswordError;
+}
+export interface ResetPasswordMutationVariables {
+    input: {
+        mobileNumber: string;
+        newPassword: string;
+    };
+    verificationCode: string;
+}
+export type ResetPasswordInput = Simplify<ResetPasswordMutationVariables['input'] & Pick<ResetPasswordMutationVariables, 'verificationCode'>>;
+export declare const resetPassword: (input: ResetPasswordInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface ProfileCompletionQuery {
+    profileCompletion: ProfileCompletion;
+}
+export declare const getProfileCompletion: (options?: GraphQLRequestOptions) => Promise<ProfileCompletion>;
+export interface PaymentSettingsQuery extends PaymentSettings {
+}
+export declare const getPaymentSettings: (options?: GraphQLRequestOptions) => Promise<PaymentSettingsQuery>;
+export type VerifyMobileNumberError = {
+    name: 'InvalidSMSVerificationCodeError';
+    message: string;
+} | {
+    name: 'MobileNumberAlreadyVerifiedError';
+    message: string;
+};
+export interface VerifyMobileNumberMutation {
+    verifyMobileNumber?: null | VerifyMobileNumberError;
+}
+export interface VerifyMobileNumberMutationVariables {
+    input: {
+        verificationCode: string;
+    };
+}
+export declare const verifyMobileNumber: (verificationCode: string, options?: GraphQLRequestOptions) => Promise<void>;
+export type CreateMemberVerificationError = {
+    name: 'FileDoesNotExistError';
+    message: string;
+} | {
+    name: 'FileNotReadyError';
+    message: string;
+} | {
+    name: 'MemberVerificationAlreadyExistsError';
+    message: string;
+};
+export interface CreateMemberVerificationMutation {
+    createMemberVerification?: null | CreateMemberVerificationError;
+}
+export interface CreateMemberVerificationMutationVariables {
+    input: {
+        id: string;
+        idFrontImage: string;
+        selfieImage: string;
+        address: string;
+        permanentAddress: string;
+        sourceOfIncome: string;
+        natureOfWork: string;
+        nationality: string;
+        placeOfBirth: string;
+    };
+}
+export type CreateMemberVerificationInput = Simplify<CreateMemberVerificationMutationVariables['input']>;
+export declare const createMemberVerification: (input: CreateMemberVerificationInput, options?: GraphQLRequestOptions) => Promise<void>;
+export declare const createMemberVerification__next: (input: CreateMemberVerificationInput, options?: GraphQLRequestOptions) => Promise<void>;
+export type UpdateMemberVerificationError = {
+    name: 'FileDoesNotExistError';
+    message: string;
+} | {
+    name: 'FileNotReadyError';
+    message: string;
+} | {
+    name: 'MemberVerificationAlreadyApprovedError';
+    message: string;
+} | {
+    name: 'MemberVerificationDoesNotExistError';
+    message: string;
+};
+export interface UpdateMemberVerificationMutation {
+    updateMemberVerification?: null | UpdateMemberVerificationError;
+}
+export interface UpdateMemberVerificationMutationVariables {
+    input: {
+        id: string;
+        data: {
+            idFrontImage?: string;
+            selfieImage?: string;
+            address?: string;
+            permanentAddress?: string;
+            sourceOfIncome?: string;
+            natureOfWork?: string;
+            nationality?: string;
+            placeOfBirth?: string;
+        };
+    };
+}
+export type UpdateMemberVerificationDataInput = Simplify<UpdateMemberVerificationMutationVariables['input']['data']>;
+export declare const updateMemberVerification: (id: string, data: UpdateMemberVerificationDataInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface MemberVerificationQuery {
+    memberAccount: {
+        verification?: MemberVerification | null;
+    };
+}
+export declare const getMemberVerification: (options?: GraphQLRequestOptions) => Promise<MemberVerification | null>;
+export interface AnnouncementsQuery extends PaginatedQuery<'announcements', Announcement> {
+}
+export interface AnnouncementsQueryVariables {
+    first?: number;
+    after?: string;
+    filter?: {
+        type?: EnumFilterField<AnnouncementType>;
+        visibility?: EnumFilterField<AnnouncementVisibility>;
+        activationStartDateTime?: DateFilterField;
+        activationEndDateTime?: DateFilterField;
+    };
+}
+export type AnnouncementsInput = SimplifyDeep<AnnouncementsQueryVariables>;
+export declare const getAnnouncements: (input?: AnnouncementsInput, options?: GraphQLRequestOptions) => Promise<import("../types").PaginatedQueryResult<Announcement>>;
+export type RegisterMayaMemberAccountError = {
+    name: 'AccountNameNotAvailableError';
+    message: string;
+};
+export interface RegisterMayaMemberAccountMutation {
+    registerMayaMemberAccount?: null | RegisterMayaMemberAccountError;
+}
+export interface RegisterMayaMemberAccountMutationVariables {
+    input: {
+        name: string;
+        password: string;
+        domain?: string;
+    };
+}
+export type RegisterMayaMemberAccountInput = Simplify<RegisterMayaMemberAccountMutationVariables['input']>;
+export declare const registerMayaMemberAccount: (input: RegisterMayaMemberAccountInput, options?: GraphQLRequestOptions) => Promise<void>;
+export interface ReferralCodeQuery {
+    referralCode?: string | null;
+}
+export declare const getReferralCode: (options?: GraphQLRequestOptions) => Promise<string | null>;
+export interface UpdateReferralCodeMutationVariables {
+    input: {
+        code: string;
+    };
+}
+export type UpdateReferralCodeError = {
+    name: 'ReferralCodeNotAvailableError';
+    message: string;
+};
+export interface UpdateReferralCodeMutation {
+    updateReferralCode?: null | UpdateReferralCodeError;
+}
+export declare const updateReferralCode: (code: string, options?: GraphQLRequestOptions) => Promise<void>;
+export interface PointsClubSettingsQuery {
+    pointsClubSettings?: PointsClubSettings | null;
+}
+export declare const getPointsClubSettings: (options?: GraphQLRequestOptions) => Promise<PointsClubSettings | null>;
+export interface GoogleClientIdQuery {
+    googleClientId?: string | null;
+}
+export declare const getGoogleClientId: (options?: GraphQLRequestOptions) => Promise<string | null>;