@eaera-com/client-sdk-v1 0.2.108

package/dist/index.d.ts

@@ -0,0 +1,1763 @@
+import { default as EaeraClientSDK } from './services/ClientSDK';
+import { default as PoolTradingSDK } from './services/PoolTradingSDK';
+import { default as UserChannel } from './channels/users';
+import { default as AccountChannel } from './channels/accounts';
+import { default as PositionChannel } from './channels/position';
+import { default as AccountMetricChannel } from './channels/metrics';
+import { default as ReportSDK } from './services/ReportSDK';
+import { default as EmailServiceTestSDK } from './services/EmailServiceTestSDK';
+
+export { EaeraClientSDK, ReportSDK, PoolTradingSDK, EmailServiceTestSDK, AccountMetricChannel, UserChannel, AccountChannel, PositionChannel, };
+export declare const stores: {
+    useAuthStore: import('pinia').StoreDefinition<"auth", {
+        user: any;
+        employee: any;
+        kyc: any;
+        client: any;
+        token: string;
+        access_token: string;
+        allow_routes: string;
+        detectedCountryCode: string;
+    }, {
+        isLoggedIn(): boolean;
+        getAllowRoutes(): string[];
+    }, {
+        formatAllowRoutesToString(allowRoutes: Array<string> | undefined): string;
+        register(payload: any): Promise<any>;
+        login(payload: any): Promise<any>;
+        loginAs(payload: any): Promise<any>;
+        loginWithToken({ token, device_id, saveToLocalStorage, }: {
+            token: string;
+            device_id?: string;
+            saveToLocalStorage?: boolean;
+        }): Promise<unknown>;
+        loginUsingDevice(email: string): Promise<unknown>;
+        registerNewDevice(email: string): Promise<unknown>;
+        send_otp(payload: any): Promise<unknown>;
+        verify_otp(issue_method: string, otp: string): Promise<unknown>;
+        webauthnVerifyOtp(email: string, otp: string, challenge: any, credential: any): Promise<unknown>;
+        logout(): Promise<any>;
+        logoutV2(): Promise<void>;
+        setToken(accessToken: string): Promise<void>;
+        fetchMe(): Promise<any>;
+        forgotPassword(payload: any): Promise<unknown>;
+        updatePassword(payload: any): Promise<unknown>;
+        getIPGeolocation(): Promise<unknown>;
+        verifyOtpAndSignIn(payload: {
+            email: string;
+            otp_code: string;
+        }): Promise<unknown>;
+    }>;
+    useContentStore: import('pinia').StoreDefinition<"content", {
+        contentIDs: {
+            user: any[];
+            client: any[];
+            lead: any[];
+            ib: any[];
+            account: any[];
+            prop_account: any[];
+            wallet: any[];
+            'request.account': any[];
+            'request.wallet': any[];
+            'request.deposit': any[];
+            'request.withdrawal': any[];
+            'request.transfer': any[];
+            'request.credit': any[];
+            'request.cross_wallet_transfer': any[];
+            'request.verification': any[];
+            'request.profile_change': any[];
+            'request.leverage': any[];
+            'request.create_ib': any[];
+            payment: any[];
+            referral: any[];
+            kyc: any[];
+            user_device: any[];
+            support_ticket: any[];
+            user_transaction: any[];
+            role_set: any[];
+            department: any[];
+            employee: any[];
+            folder: any[];
+            certificate: any[];
+            certificate_type: any[];
+            voip_call: any[];
+            coupon: any[];
+            product: any[];
+            coupon_redemption: any[];
+            purchase: any[];
+            commission_profile: any[];
+            product_addon_category: any[];
+            membership: any[];
+            combine: {};
+        };
+        contents: {
+            user: any[];
+            client: any[];
+            lead: any[];
+            ib: any[];
+            account: any[];
+            prop_account: any[];
+            wallet: any[];
+            'request.account': any[];
+            'request.wallet': any[];
+            'request.deposit': any[];
+            'request.withdrawal': any[];
+            'request.transfer': any[];
+            'request.cross_wallet_transfer': any[];
+            'request.credit': any[];
+            'request.verification': any[];
+            'request.profile_change': any[];
+            'request.leverage': any[];
+            'request.create_ib': any[];
+            payment: any[];
+            referral: any[];
+            kyc: any[];
+            user_device: any[];
+            support_ticket: any[];
+            user_transaction: any[];
+            role_set: any[];
+            department: any[];
+            employee: any[];
+            folder: any[];
+            certificate: any[];
+            certificate_type: any[];
+            voip_call: any[];
+            notification_user: any[];
+            coupon: any[];
+            product: any[];
+            coupon_redemption: any[];
+            purchase: any[];
+            commission_profile: any[];
+            product_addon_category: any[];
+            membership: any[];
+            combine: {};
+            note: any[];
+            lending: any[];
+        };
+        filterAndOrder: {
+            user: string;
+            client: string;
+            lead: string;
+            ib: string;
+            account: string;
+            prop_account: string;
+            wallet: string;
+            'request.account': string;
+            'request.wallet': string;
+            'request.deposit': string;
+            'request.withdrawal': string;
+            'request.transfer': string;
+            'request.cross_wallet_transfer': string;
+            'request.credit': string;
+            'request.verification': string;
+            'request.profile_change': string;
+            'request.leverage': string;
+            'request.create_ib': string;
+            payment: string;
+            referral: string;
+            kyc: string;
+            user_device: string;
+            support_ticket: string;
+            user_transaction: string;
+            role_set: string;
+            department: string;
+            employee: string;
+            folder: string;
+            certificate: string;
+            certificate_type: string;
+            voip_call: string;
+            coupon: any[];
+            product: any[];
+            coupon_redemption: any[];
+            purchase: any[];
+            commission_profile: any[];
+            notification_user: string;
+            membership: string;
+            combine: {};
+        };
+        lastUpdateAt: {
+            user: {};
+            client: {};
+            lead: {};
+            ib: {};
+            account: {};
+            prop_account: {};
+            wallet: {};
+            'request.account': {};
+            'request.wallet': {};
+            'request.deposit': {};
+            'request.withdrawal': {};
+            'request.transfer': {};
+            'request.credit': {};
+            'request.cross_wallet_transfer': {};
+            'request.verification': any[];
+            'request.profile_change': any[];
+            'request.leverage': any[];
+            'request.create_ib': any[];
+            payment: {};
+            referral: {};
+            kyc: {};
+            user_device: {};
+            support_ticket: {};
+            user_transaction: {};
+            role_set: {};
+            department: {};
+            employee: {};
+            folder: {};
+            certificate: {};
+            certificate_type: {};
+            voip_call: {};
+            commission_profile: any[];
+            membership: {};
+            combine: {};
+        };
+        pageSize: {
+            user: number;
+            client: number;
+            lead: number;
+            ib: number;
+            account: number;
+            prop_account: number;
+            wallet: number;
+            'request.account': number;
+            'request.wallet': number;
+            'request.deposit': number;
+            'request.withdrawal': number;
+            'request.transfer': number;
+            'request.cross_wallet_transfer': number;
+            'request.credit': number;
+            'request.verification': number;
+            'request.profile_change': number;
+            'request.leverage': number;
+            'request.create_ib': number;
+            payment: number;
+            referral: number;
+            kyc: number;
+            user_device: number;
+            support_ticket: number;
+            user_transaction: number;
+            role_set: number;
+            department: number;
+            employee: number;
+            folder: number;
+            certificate: number;
+            certificate_type: number;
+            voip_call: number;
+            coupon: any[];
+            product: any[];
+            coupon_redemption: any[];
+            purchase: any[];
+            commission_profile: any[];
+            membership: number;
+            combine: {};
+        };
+        contentLastUpdateAt: string;
+    }, {}, {
+        fetchContentIDsInTimeRange(content_type: any, from_time?: any, to_time?: any, filter?: {}, order_by?: {
+            key: string;
+            direction: string;
+        }, concat?: boolean): Promise<void>;
+        fetchContents(content_type: any, page: any, size: any, filter: any, order_by: any, from_time?: any, to_time?: any, concat?: boolean, with_attachments?: boolean): Promise<any>;
+        fetchContentByUUID(content_type: string, uuid: string): Promise<any>;
+        exportContents(payload: any): Promise<any>;
+        updateContent(content_type: string, id: number, payload: any): void;
+        deleteContent(content_type: string, id: number): void;
+        addContent(content_type: string, payload: any): void;
+        transit2(payload: any): Promise<any>;
+        act(payload: any, options?: any): Promise<any>;
+        createContent(payload: any, params?: any, with_attachments?: boolean): Promise<any>;
+        updateContentByApi(payload: any, ct_id: string | number, with_attachments?: boolean): Promise<any>;
+        deleteContentByApi(content_type: string, ct_id: string | number): Promise<any>;
+        performAction(payload: any, withAttachments?: boolean): Promise<any>;
+    }>;
+    useContentV2Store: import('pinia').StoreDefinition<"content-v2", {
+        total: {
+            user: number;
+            client: number;
+            lead: number;
+            ib: number;
+            account: number;
+            prop_account: number;
+            wallet: number;
+            'request.account': number;
+            'request.wallet': number;
+            'request.deposit': number;
+            'request.withdrawal': number;
+            'request.transfer': number;
+            'request.credit': number;
+            'request.cross_wallet_transfer': number;
+            'request.verification': number;
+            'request.profile_change': number;
+            'request.leverage': number;
+            payment: number;
+            referral: number;
+            kyc: number;
+            user_device: number;
+            support_ticket: number;
+            user_transaction: number;
+            role_set: number;
+            department: number;
+            employee: number;
+            folder: number;
+            certificate: number;
+            voip_call: number;
+            coupon: number;
+            product: number;
+            coupon_redemption: number;
+            purchase: number;
+            combine: {};
+        };
+        dataCache: {
+            user: any[];
+            client: any[];
+            lead: any[];
+            ib: any[];
+            account: any[];
+            prop_account: any[];
+            wallet: any[];
+            'request.account': any[];
+            'request.wallet': any[];
+            'request.deposit': any[];
+            'request.withdrawal': any[];
+            'request.transfer': any[];
+            'request.cross_wallet_transfer': any[];
+            'request.credit': any[];
+            'request.verification': any[];
+            'request.profile_change': any[];
+            'request.leverage': any[];
+            payment: any[];
+            referral: any[];
+            kyc: any[];
+            user_device: any[];
+            support_ticket: any[];
+            user_transaction: any[];
+            role_set: any[];
+            department: any[];
+            employee: any[];
+            folder: any[];
+            certificate: any[];
+            voip_call: any[];
+            coupon: any[];
+            product: any[];
+            coupon_redemption: any[];
+            purchase: any[];
+            combine: {};
+        };
+        contents: {
+            user: any[];
+            client: any[];
+            lead: any[];
+            ib: any[];
+            account: any[];
+            prop_account: any[];
+            wallet: any[];
+            'request.account': any[];
+            'request.wallet': any[];
+            'request.deposit': any[];
+            'request.withdrawal': any[];
+            'request.transfer': any[];
+            'request.cross_wallet_transfer': any[];
+            'request.credit': any[];
+            'request.verification': any[];
+            'request.profile_change': any[];
+            'request.leverage': any[];
+            payment: any[];
+            referral: any[];
+            kyc: any[];
+            user_device: any[];
+            support_ticket: any[];
+            user_transaction: any[];
+            role_set: any[];
+            department: any[];
+            employee: any[];
+            folder: any[];
+            certificate: any[];
+            voip_call: any[];
+            notification_user: any[];
+            coupon: any[];
+            product: any[];
+            coupon_redemption: any[];
+            purchase: any[];
+            combine: {};
+        };
+        filterAndOrder: {
+            user: string;
+            client: string;
+            lead: string;
+            ib: string;
+            account: string;
+            prop_account: string;
+            wallet: string;
+            'request.account': string;
+            'request.wallet': string;
+            'request.deposit': string;
+            'request.withdrawal': string;
+            'request.transfer': string;
+            'request.cross_wallet_transfer': string;
+            'request.credit': string;
+            'request.verification': string;
+            'request.profile_change': string;
+            'request.leverage': string;
+            payment: string;
+            referral: string;
+            kyc: string;
+            user_device: string;
+            support_ticket: string;
+            user_transaction: string;
+            role_set: string;
+            department: string;
+            employee: string;
+            folder: string;
+            certificate: string;
+            voip_call: string;
+            coupon: string;
+            product: string;
+            coupon_redemption: string;
+            purchase: string;
+            combine: {};
+        };
+    }, {}, {
+        fetchContents(content_type: any, page: any, size: any, filter?: {}, order_by?: {}, joined_columns?: any[], forceRefresh?: boolean): Promise<{
+            data: any;
+            page: any;
+            page_size: any;
+            total: any;
+        }>;
+        _getCacheStore(key: any, isCombined: any): {
+            dataCache: any;
+            contents: any;
+            total: any;
+            filterAndOrder: any;
+        };
+    }>;
+    useClientStore: import('pinia').StoreDefinition<"client", {
+        client: any;
+        clients: any[];
+        clientCount: number;
+        fundedClientCount: number;
+        activeClientCount: number;
+        dailyHistoryClientCount: any[];
+        activePropAccount: number;
+    }, {}, {
+        fetchClientsCount(): Promise<any>;
+        fetchFundedClientsCount(): Promise<any>;
+        fetchActiveClientsCount(payload?: any): Promise<any>;
+        fetchClients(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        countDailyHistoryClients(payload: any): Promise<any>;
+        fetchCountHasActivePropAcc(): Promise<any>;
+    }>;
+    useCouponStore: import('pinia').StoreDefinition<"coupon", {
+        coupons: any[];
+        publicCoupons: import('./common/types/coupon.type').PublicCoupon[];
+        couponRedemptions: any[];
+        selectedCoupon: {};
+    }, {
+        couponsTotalCount(): number;
+    }, {
+        fetchCoupons(payload?: {
+            page?: number;
+            size?: number;
+            filter?: any;
+            order_by?: any;
+            from_time?: any;
+            to_time?: any;
+        }): Promise<any[]>;
+        createCoupon(payload: import('./services/ClientSDK/coupon/type').CouponPayload): Promise<unknown>;
+        updateCoupon(id: string, payload: import('./services/ClientSDK/coupon/type').CouponPayload): Promise<unknown>;
+        enableCoupon(id: string): Promise<unknown>;
+        disableCoupon(id: string): Promise<unknown>;
+        createCouponRedemption(payload: import('./services/ClientSDK/coupon/type').RedemptionPayload): Promise<import('./services/ClientSDK/coupon/type').RedemptionResponse | null>;
+        createCouponRedemptionAnonymous(payload: import('./services/ClientSDK/coupon/type').RedemptionPayload): Promise<import('./services/ClientSDK/coupon/type').RedemptionResponse | null>;
+        fetchAvailableCouponRedemptions(email: string): Promise<import('./services/ClientSDK/coupon/type').RedemptionResponse[]>;
+        fetchAvailableCouponRedemptionsAnonymous(email: string): Promise<unknown>;
+        fetchPublicCoupons(): Promise<import('./common/types/coupon.type').PublicCoupon[]>;
+        updateCouponCommission(id: string, payload: FormData): Promise<unknown>;
+    }>;
+    useProductAttributeStore: import('pinia').StoreDefinition<"product_attribute", {
+        product_attributes: any[];
+        selectedProductAttribute: {};
+    }, {}, {
+        fetchProductAttributes(isEcommereService?: boolean): Promise<any>;
+        fetchProductAttributeByUUID(uuid: number, isEcommereService?: boolean): Promise<any>;
+        createProductAttribute(payload: any, isEcommereService?: boolean): Promise<any>;
+        updateProductAttribute(uuid: number, payload: any, isEcommereService?: boolean): Promise<any>;
+        deleteProductAttribute(uuid: number, isEcommereService?: boolean): Promise<any>;
+    }>;
+    useProductStore: import('pinia').StoreDefinition<"product", {
+        products: any[];
+        selectedProduct: {};
+        categorizedProducts: {
+            prop_account: any[];
+            trading_competition: any[];
+            prop_trading_competition: any[];
+            leveraged: any[];
+        };
+        staticsCompetitions: import('./common/types').IStaticsCompetition[];
+    }, {
+        productsTotalCount(): number;
+        propTradingCompetitionProducts(): {
+            upcoming: any;
+            ongoing: any;
+            finished: any;
+        };
+        calculatePlatformPrice(): (platform: import('./common/types').IProgramPlatformSettings, variationData: import('./common/types').IVariation, currency: string) => number;
+    }, {
+        fetchProducts(payload?: any, isChangeStore?: boolean, categoryName?: import('./common/types').CategoryName, isFetchContent?: boolean): Promise<any>;
+        fetchProductByUUID(uuid: string, isEcommereService?: boolean): Promise<any>;
+        fetchLevelByProduct(product_uuid: string, product_level: any, isEcommereService?: boolean): Promise<any>;
+        createProduct(payload: any, isEcommereService?: boolean): Promise<any>;
+        createProductAndVariation(payload: any, isEcommereService?: boolean): Promise<any>;
+        updateProduct(id: string | number, payload: any): Promise<any>;
+        deleteProduct(id: string | number): Promise<any>;
+        fetchStatisticsCompetitions(product_uuids: string[] | number[]): Promise<any>;
+    }>;
+    useCategoryStore: import('pinia').StoreDefinition<"category", {
+        categories: any[];
+        selectedCategory: {};
+    }, {
+        categoriesTotalCount(): number;
+        categoryByName(): (name: import('./common/types').CategoryName) => any;
+    }, {
+        fetchCategories(payload?: any): Promise<any>;
+        fetchCategoryByUUID(uuid: string, isEcommereService?: boolean): Promise<any>;
+        createCategory(payload: any, isEcommereService?: boolean): Promise<any>;
+        updateCategory(uuid: string, payload: any, isEcommereService?: boolean): Promise<any>;
+        deleteCategory(uuid: string, isEcommereService?: boolean): Promise<any>;
+    }>;
+    useLeadStore: import('pinia').StoreDefinition<"lead", {
+        lead: any;
+        leads: any[];
+        leadCount: number;
+        fundedLeadCount: number;
+        activeLeadCount: number;
+        dailyHistoryLeadCount: any[];
+    }, {}, {
+        fetchLeadsCount(): Promise<any>;
+        fetchLeads(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        countDailyHistoryLeads(payload: any): Promise<any>;
+        activateImportedLead(id: number): Promise<any>;
+    }>;
+    useWalletStore: import('pinia').StoreDefinition<"wallet", {
+        wallets: any[];
+        walletBalanceChanges: {};
+        selected_wallet: {};
+        walletDWPeriod: {};
+        walletDeposit: {};
+        walletWithdrawal: {};
+        walletTransferIn: {};
+        walletTransferOut: {};
+        fundingHistory: {};
+        referral_wallet_id: any;
+    }, {
+        getCategoryWallet: (state: {
+            wallets: any[];
+            walletBalanceChanges: {};
+            selected_wallet: {};
+            walletDWPeriod: {};
+            walletDeposit: {};
+            walletWithdrawal: {};
+            walletTransferIn: {};
+            walletTransferOut: {};
+            fundingHistory: {};
+            referral_wallet_id: any;
+        } & import('pinia').PiniaCustomStateProperties<{
+            wallets: any[];
+            walletBalanceChanges: {};
+            selected_wallet: {};
+            walletDWPeriod: {};
+            walletDeposit: {};
+            walletWithdrawal: {};
+            walletTransferIn: {};
+            walletTransferOut: {};
+            fundingHistory: {};
+            referral_wallet_id: any;
+        }>) => (category?: import('./common/types').WalletCategory) => any[];
+    }, {
+        fetchWallets(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        fetchOneWallet(wallet_id: number): Promise<any>;
+        fetchWalletBalanceChanges(ids?: number[]): Promise<any>;
+        getWalletSumDeposit(id: any): Promise<any>;
+        getWalletSumWithdrawal(id: any): Promise<any>;
+        getWalletSumTransferIn(id: any): Promise<any>;
+        getWalletSumTransferOut(id: any): Promise<any>;
+        setMainWallet(wallet_id: number): Promise<any>;
+        fetchWalletFundingHistory(payload: any): Promise<any>;
+        fetchWalletPublicInfoByEmail(email: string): Promise<any>;
+        getWalletPublicInfo(email: string): Promise<any>;
+        fetchDetachedInvestWallets(): Promise<any>;
+        fetchAllWalletsByCategory(category: string): Promise<any>;
+        fetchFundingByWallet(walletId: number): Promise<any>;
+    }>;
+    useAccountStore: import('pinia').StoreDefinition<"account", {
+        accounts: any[];
+        accountHistory: {};
+        selected_account: {};
+        fundingHistory: {};
+        openTrades: {};
+        mtDeals: any[];
+        totalDeals: number;
+        positions: any[];
+        totalPositions: number;
+        options: string;
+        accountsIndexMap: {};
+        accountMetricByDeal: any[];
+        columnsTrade: any;
+    }, {
+        liveAccounts(state: {
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        } & import('pinia').PiniaCustomStateProperties<{
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        }>): any[];
+        demoAccounts(state: {
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        } & import('pinia').PiniaCustomStateProperties<{
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        }>): any[];
+        poolLiveAccounts(state: {
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        } & import('pinia').PiniaCustomStateProperties<{
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        }>): any[];
+        accountFundingHistory(state: {
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        } & import('pinia').PiniaCustomStateProperties<{
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        }>): {};
+        closedDeals(): (formatMoney: any, digits: any) => any;
+        openPositions(): (formatMoney: any, digits: any) => any;
+        getColumnsTrade(state: {
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        } & import('pinia').PiniaCustomStateProperties<{
+            accounts: any[];
+            accountHistory: {};
+            selected_account: {};
+            fundingHistory: {};
+            openTrades: {};
+            mtDeals: any[];
+            totalDeals: number;
+            positions: any[];
+            totalPositions: number;
+            options: string;
+            accountsIndexMap: {};
+            accountMetricByDeal: any[];
+            columnsTrade: any;
+        }>): any;
+    }, {
+        fetchAccounts(page: any, size: any, filter: any, order_by: any, skipPullTrading?: boolean): Promise<any>;
+        fetchOneAccount(account_id: number): Promise<any>;
+        fetchOpenTrades(account_id: number): Promise<any>;
+        listPositions(account_id: number, position_type: string, symbol?: string): Promise<any>;
+        fetchAccountHistory(server: string, account_ids: number[], from_date: string, to_date: string): Promise<any>;
+        fetchAccountFundingHistory(account_id: any, dateFrom: any, dateTo: any): Promise<any>;
+        changeLeverage(account_id: number): Promise<any>;
+        resetPassword(account_id: number): Promise<any>;
+        depositDemo(account_id: number): Promise<any>;
+        resetBalance(account_id: number): Promise<any>;
+        getAccountSummary(payload: any): Promise<any>;
+        getDeals(payload: any): Promise<any>;
+        countDeals(payload: any): Promise<any>;
+        exportDeals(payload: any): Promise<any>;
+        getPostions(payload: any): Promise<any>;
+        countPositions(payload: any): Promise<any>;
+        getMostProfitablePairs(account_id: any): Promise<any>;
+        getProfitLossHistory(account_id: number, payload: any): Promise<any>;
+        getOverallROI(account_id: number): Promise<any>;
+        getAccountBalanceToCompareDate(payload: any): Promise<any>;
+        loadColumnsFromStorage(): void;
+        updateColumnsTrade(payload: string[]): void;
+        getWithdrawableAccounts(payload: {
+            server: string;
+            logins: number[];
+        }): Promise<any>;
+        getAccountMetricByLastDeals(ids: number[]): Promise<any>;
+    }>;
+    usePropAccountStore: import('pinia').StoreDefinition<"prop_account", {
+        prop_accounts: any[];
+        accountHistory: {};
+        selected_account: {};
+        fundingHistory: {};
+        openTrades: {};
+        positions: any[];
+        totalPositions: number;
+        options: string;
+        accountsIndexMap: {};
+        defaultFields: string[];
+        metricData: any[];
+        countMetricData: number;
+        rankingMetricData: any[];
+        countRankingMetricData: number;
+        equities: any[];
+        accountMetricByDeal: any[];
+        maxBalanceEquity: number;
+        dailyDrawdownThresholds: any[];
+        accountOnUpdate: any[];
+    }, {
+        closedPositions(): (server: any, formatMoney: any) => any;
+    }, {
+        fetchAccounts(page: any, size: any, filter: any, order_by: any, with_attachments?: boolean, skipPullTrading?: boolean): Promise<any>;
+        getPositions(payload: any): Promise<any>;
+        countPositions(payload: any): Promise<any>;
+        recalculateAccountMetrics(account_ids: any): Promise<any>;
+        getPublicAccountsInfo(payload: any): Promise<any>;
+        propAccountMostTradedAsset(payload: any): Promise<any>;
+        propAccountsMetrics(payload: any): Promise<any>;
+        propAccountMetricsCount(payload: any): Promise<any>;
+        getAccountMetricByLastDeal(ids: number[]): Promise<any>;
+        fetchDailyDrawdowmThresholdMetric(payload: any): Promise<any>;
+        fetchDailyDrawdownThresholds(payload: any): Promise<any>;
+        toggleHidePropAccount(id: number): Promise<any>;
+        fetchAccountOnUpdate(payload: any): Promise<any>;
+        changeInvestorAccountPassword(payload: {
+            id: number;
+            password: string;
+        }): Promise<any>;
+        changePropAccountPassword(payload: {
+            id: number;
+            new_password: string;
+            role: "master" | "investor" | null;
+        }): Promise<any>;
+        resumeMembership(id: string): Promise<unknown>;
+        cancelMembership(id: string): Promise<unknown>;
+    }>;
+    useRequestStore: import('pinia').StoreDefinition<"request", {
+        requests: any[];
+        selected_request: {};
+        verification: any[];
+        paymentMethod: {};
+    }, {}, {
+        fetchRequests(request_types: string[] | string, page: number, size: number, filter: object, order_by: object): Promise<any>;
+        fetchOneRequest(request_id: number): Promise<any>;
+        createRequest(payload: any, options?: any): Promise<any>;
+        createWalletRequest(payload: any): Promise<any>;
+        createAccountRequest(payload: any, request_type: string): Promise<any>;
+        createDepositRequest(payload: any): Promise<any>;
+        createDemoDepositRequest(payload: any): Promise<any>;
+        createWithdrawalRequest(payload: any): Promise<any>;
+        createTransferRequest(payload: any): Promise<any>;
+        createLeadImportRequest(payload: any): Promise<any>;
+        changeLeverage(account_id: number, payload: any, request_type: string): Promise<any>;
+        resetPassword(account_id: number): Promise<any>;
+        uploadPaymentProof(request_id: number, payload: any): Promise<any>;
+        importLeadFile(request_id: number, payload: any): Promise<any>;
+        importIBFile(request_id: number, payload: any): Promise<any>;
+        uploadTradingReports(request_id: number, payload: any): Promise<any>;
+        cancelRequest(request_id: number): Promise<any>;
+        depositPSP(payload: any): Promise<any>;
+        withdrawPSP(payload: any): Promise<any>;
+        callPaymentMethodFunc(payload: any): Promise<any>;
+        approveRequest(request_id: number): Promise<any>;
+        rejectRequest(request_id: number, payload: any): Promise<any>;
+        bulkApproveRequest(ids: number[]): Promise<any>;
+        bulkRejectRequest(payload: any): Promise<any>;
+        reprocessRequest(request_id: number): Promise<any>;
+        updateThenApproveRequest(request_id: number, params_fields: any): Promise<any>;
+        updateExtraData(id: any, payload: any): Promise<unknown>;
+        reviewKycDocument(id: any, payload: any): Promise<unknown>;
+        undoKycDocument(id: any, payload: any): Promise<unknown>;
+        reactivateTradingAccount(payload: any, user_id: number): Promise<unknown>;
+        disableTradingAccount(payload: any, user_id: number): Promise<unknown>;
+        generateTodayReport(poolId: number): Promise<unknown>;
+    }>;
+    useFundingSourceStore: import('pinia').StoreDefinition<"funding-source", {
+        fundingSources: import('./common/types/fundingSource.type').FundingSourceResponse[];
+        fundingMethods: import('./common/types/fundingSource.type').FundingMethodResponse[];
+    }, {
+        availableFundingMethods(): (params?: {
+            countryCode?: string;
+            active?: boolean;
+            transactionType?: "deposit" | "withdrawal";
+        }) => import('./common/types/fundingSource.type').FundingMethodWithRules[];
+        availableFundingMethodsByTransactionType(): (params: {
+            transactionType: "deposit" | "withdrawal";
+            filterConditions?: import('./common/types/common.type').LooseObject;
+            countryCode?: string;
+        }) => import('./common/types/fundingSource.type').FundingMethodWithRules[];
+        availableTransactionRuleDetail(): (params: {
+            method: string;
+            ruleKey: string;
+            countryCode?: string;
+        }) => import('./common/types/fundingSource.type').DepositRule | import('./common/types/fundingSource.type').WithdrawalRule | import('./common/types/fundingSource.type').TransactionRule | null;
+        allowedCurrencies(): (params: {
+            method: string;
+            type: "all" | "fiat" | "crypto";
+            transactionType: "deposit" | "withdrawal";
+        }) => string[];
+        allFundingMethodsWithSources(): (params?: {
+            active?: boolean;
+        }) => import('./common/types/fundingSource.type').FundingMethodWithSources[];
+    }, {
+        fetchFundingSources(): Promise<import('axios').AxiosResponse<import('./common/types/fundingSource.type').FundingSourceResponse[]>>;
+        createFundingSource(payload: import('./common/types/fundingSource.type').FundingSourcePayload, otpCode: string): Promise<import('axios').AxiosResponse<import('./common/types/fundingSource.type').CreateFundingSourceResponse>>;
+        editFundingSource(payload: import('./common/types/fundingSource.type').FundingSourcePayload & {
+            id: number | string;
+        }, otpCode: string): Promise<import('axios').AxiosResponse<import('./common/types/fundingSource.type').FundingSourceResponse>>;
+        deleteFundingSource(payload: {
+            id: number | string;
+        }, otpCode: string): Promise<import('axios').AxiosResponse<Object>>;
+        getFundingMethods(): Promise<import('axios').AxiosResponse<import('./common/types/fundingSource.type').FundingMethodResponse[]>>;
+        sendOtpFundingSource(email?: string): Promise<import('axios').AxiosResponse<number>>;
+    }>;
+    useSiteSettingStore: import('pinia').StoreDefinition<"site-setting", import('./stores/siteSetting').ISiteSetting, {
+        settingsByPath(): (path: string[]) => any;
+        fieldFromSetting(): (setting_path: any, index_path: any) => any;
+        countrySettings(): any;
+        tradingPlatformsChildrenSettings(): any[];
+        liveServers(): any;
+        demoServers(): any;
+        battleServers(): any;
+        allServers(): any;
+        accountTypes(): (server: any) => any;
+        accountRules(): (server: any) => any;
+        accountCurrencies(): (server: any) => any;
+        accountLeverageTypes(): (server: any) => any;
+        accountPromotions(): (server: any) => any;
+        storageSettings(): (server: any) => any;
+        companySettings(): import('./common/types').CompanySettings;
+        walletSetupCurrency(): any;
+        getCompanySites(): Record<import('./common/types').SiteName, string> | undefined;
+        currencyDigitSettings(): (server: any) => any;
+        reportSettings(): any;
+        getAvailabledFiatAndCryptoCurrencies(): (isByType?: boolean, filterByEnabled?: boolean) => any[] | {
+            fiat: any;
+            crypto: any;
+        };
+        getCurrencyDigit(): (currency: string) => any;
+        availableCountries(): {
+            countryName: string;
+            countryShortCode: string;
+            value: string;
+            regions: ({
+                name: string;
+                shortCode?: undefined;
+            } | {
+                name: string;
+                shortCode: string;
+            })[];
+            label: string;
+            languages: string;
+            dialling_code: string;
+        }[];
+        traderReferral(): any;
+        traderReferralSettings(): any;
+        getEnabledPasswordRules(): import('./common/types').PasswordRule[];
+    }, {
+        set_settings({ path, data }: {
+            path: string[];
+            data: any;
+        }): void;
+        fetchSiteSettings(path: string[], recursive?: boolean): Promise<any>;
+        fetchPublicSiteSettings(path: string[], recursive?: boolean): Promise<any>;
+        updateSettings(path: string[], data: any, overwrite?: boolean): Promise<unknown>;
+        createSetting(path: string[], data: any, short_name: string): Promise<unknown>;
+        deleteSetting(path: string[]): Promise<unknown>;
+        uploadAttachment(path: string[], payload: any): Promise<unknown>;
+        testEmail(payload: string): Promise<unknown>;
+        syncAccountGroupConfigs(server: string): Promise<unknown>;
+        syncSymbolConfigs(server: string): Promise<unknown>;
+        getServerTimeOffset(server: string): Promise<unknown>;
+        getMachineTranslation(payload: any): Promise<unknown>;
+        getWidgetIframeSettings(): Promise<unknown>;
+    }>;
+    useKycStore: import('pinia').StoreDefinition<"kyc", {
+        kycs: any[];
+        selected_kyc: {};
+    }, {}, {
+        fetchKycs(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        updateKycs(id: any, payload: any): Promise<unknown>;
+        findOrInitializeKyc(payload: any): Promise<unknown>;
+        uploadDocument(id: any, payload: any): Promise<unknown>;
+        updateExtraData(id: any, payload: any): Promise<unknown>;
+        uploadIdImage(id: any, payload: any): Promise<unknown>;
+        uploadAddressImage(id: any, payload: any): Promise<unknown>;
+        uploadPotraitImage(id: any, payload: any): Promise<unknown>;
+        approveKyc(id: any, payload: any): Promise<unknown>;
+        rejectKyc(id: any, payload: any): Promise<unknown>;
+        bulkRejectKyc(payload: any): Promise<unknown>;
+    }>;
+    useMetricStore: import('pinia').StoreDefinition<"metric", {
+        accountMetricByDealFields: string[];
+        positionMetricByDealFields: string[];
+        dailyDrawdownThresholdFields: string[];
+        mtAccountEquityFields: string[];
+        metricData: any[];
+        propAccountMetricData: any[];
+        latestMetricData: {};
+    }, {
+        metricDataByLogin(): (login: string, server: string) => any;
+        getLatestMetricDataByMetricName(): (metric_name: string) => any;
+    }, {
+        setMetricData(data: any, fields: any): void;
+        queryMetric(payload: any, isNoFields?: boolean): Promise<any>;
+        queryMetricByTimetamp(payload: any): Promise<any>;
+        queryLatestMetric(payload: {
+            metric_name: string;
+            server_logins: {
+                server: string;
+                login: string;
+            }[];
+            fields: string[];
+        }): Promise<any>;
+    }>;
+    useMetricV2Store: import('pinia').StoreDefinition<"metric-v2", {
+        account_metric_by_deal: import('./services/ClientSDK/metric/type').AccountMetricByDeal[];
+        mt_account_equity: import('./services/ClientSDK/metric/type').MtAccountEquity[];
+        min_equity_by_login: import('./services/ClientSDK/metric/type').MinEquityByLogin[];
+        mt_account_history: import('./services/ClientSDK/metric/type').MtAccountHistory[];
+        mt_account_history_by_week: import('./services/ClientSDK/metric/type').MtAccountHistory[];
+        mt_account_history_by_month: import('./services/ClientSDK/metric/type').MtAccountHistory[];
+        account_metric_by_day_of_week: import('./services/ClientSDK/metric/type').AccountMetricByDayOfWeek[];
+        account_metric_by_date: import('./services/ClientSDK/metric/type').AccountMetricByDate[];
+        account_symbol_metric_by_deal: import('./services/ClientSDK/metric/type').AccountSymbolMetricByDeal[];
+        position_metric_by_deal: import('./services/ClientSDK/metric/type').PositionMetricByDeal[];
+        most_traded_asset: import('./services/ClientSDK/metric/type').MostTradedAsset[];
+    }, {}, {
+        queryMetric(payload: import('./services/ClientSDK/metric/type').QueryMetricV2Payload): Promise<any>;
+        queryAccountMetricByDeal(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').AccountMetricByDealFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryMtAccountEquity(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').MtAccountEquityFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryMinEquityByLogin(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').MtAccountEquityFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryMtAccountHistory(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').MtAccountHistoryFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryMtAccountHistoryByWeek(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').MtAccountHistoryFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryMtAccountHistoryByMonth(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').MtAccountHistoryFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryAccountMetricByDayOfWeek(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').AccountMetricByDayOfWeekFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryAccountMetricByDate(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').AccountMetricByDateFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryAccountSymbolMetricByDeal(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').AccountSymbolMetricByDealFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryPositionMetricByDeal(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').PositionMetricByDealFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+        queryMostTradedAsset(server_logins: import('./services/ClientSDK/metric/type').ServerLogin[], fields?: import('./services/ClientSDK/metric/type').MostTradedAssetFields[], order_by?: import('./services/ClientSDK/metric/type').OrderBy[], order?: "asc" | "desc", offset?: number, limit?: number): Promise<any>;
+    }>;
+    useDevicesStore: import('pinia').StoreDefinition<"devices", {
+        devices: any[];
+        trustedDevices: any[];
+    }, {}, {
+        fetchDevices(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        signOutAll(except_current: any): Promise<any>;
+        untrustDevices(id: any): Promise<any>;
+    }>;
+    useUserStore: import('pinia').StoreDefinition<"user", {
+        users: any[];
+        selectedUser: any;
+    }, {}, {
+        changePassword(payload: any): Promise<unknown>;
+        precheckChangeEmail(payload: any): Promise<unknown>;
+        changeEmail(payload: any): Promise<unknown>;
+        getGoogleAuthUri(): Promise<unknown>;
+        updateTwoFASetting(payload: any): Promise<unknown>;
+        uploadProfilePicture(payload: any): Promise<unknown>;
+        profileChange(payload: any): Promise<unknown>;
+        updateUser(user_id: number, payload: any): Promise<unknown>;
+        getWidgetSettings(): Promise<unknown>;
+        updateWidgetSettings(payload: any): Promise<unknown>;
+        tradingCentralHandshakeUrl(payload: any): Promise<unknown>;
+        getWidgetData(payload: any): Promise<unknown>;
+        getProfilePictures(payload: any): Promise<unknown>;
+        setPassword(payload: any): Promise<unknown>;
+        getReferralReward(payload: any): Promise<unknown>;
+        sendContactSupportMessage(payload: {
+            email: string;
+            message: string;
+        }): Promise<unknown>;
+        processDataFromCampaignLandingPage(payload: any): Promise<unknown>;
+        sendOtpToEmail(payload: {
+            email: string;
+            issue_method: string;
+        }): Promise<unknown>;
+        updateSelectedUser(user: any): void;
+    }>;
+    useSupportStore: import('pinia').StoreDefinition<"support", {
+        supportTickets: any[];
+        selectedTicket: {};
+        timeFilter: string;
+    }, {
+        getOpenSupportTickets: (state: {
+            supportTickets: any[];
+            selectedTicket: {};
+            timeFilter: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            supportTickets: any[];
+            selectedTicket: {};
+            timeFilter: string;
+        }>) => any[];
+        getClosedSupportTickets: (state: {
+            supportTickets: any[];
+            selectedTicket: {};
+            timeFilter: string;
+        } & import('pinia').PiniaCustomStateProperties<{
+            supportTickets: any[];
+            selectedTicket: {};
+            timeFilter: string;
+        }>) => any[];
+    }, {
+        fetchSupportTickets({ owner_id, state }: any): Promise<any>;
+        fetchSingleSupportTicket(id: string | number): Promise<any>;
+        createTicket(payload: any): Promise<unknown>;
+        updateTicket(payload: any, id: string | number): Promise<unknown>;
+        messageSupportTicket(payload: any, id: string | number): Promise<unknown>;
+        closeSupportTicket(id: string | number): Promise<unknown>;
+        updateTimeFilter(filter: string): void;
+        updateStateTicket(state: string): void;
+    }>;
+    useTransactionStore: import('pinia').StoreDefinition<"transaction", {
+        transactions: any[];
+        transactionPeriod: {};
+    }, {
+        walletTransactions(): any;
+    }, {
+        fetchTransactions(page: any, size: any, filter: any, order_by: any): Promise<any>;
+    }>;
+    usePoolProfileStore: import('pinia').StoreDefinition<"pool_profile", {
+        poolProfileIds: any[];
+        poolProfiles: any[];
+        poolProfileLastFetchedAt: any;
+        poolProfileFilterAndOrder: string;
+        selectedPoolProfile: {};
+        poolProfileLeaderboard: any[];
+        mtDeals: any[];
+        totalDeals: number;
+        positions: any[];
+        totalPositions: number;
+        positionsStateOpenLiveUpdate: import('./stores/poolProfile').IPositionInvestWallet[];
+        poolProfileLiveUpdate: {};
+    }, {
+        getFilter(): any;
+        getOrder(): any;
+        poolProfilesTotalCount(): any;
+        closedDeals(): (server: any, formatMoney: any) => any;
+        openPositions(): (server: any, formatMoney: any) => any;
+    }, {
+        reorderAndFilterPoolProfiles(): void;
+        insertOrUpdatePoolProfile(poolProfile: any): void;
+        updatePoolProfile(id: number, data: any): Promise<any>;
+        updatePoolProfileAdmin(id: number, data: any): Promise<any>;
+        fetchPoolProfile(id: number): Promise<any>;
+        fetchPoolProfileById(pool_id: number, setStore?: {
+            isSetStore?: boolean;
+            props?: {
+                investWallet?: any;
+                state?: "open" | "closed";
+            };
+        }): Promise<any>;
+        fetchPoolProfileIDsInTimeRange(from_time?: Date, to_time?: Date, filter?: any, order?: any): Promise<any>;
+        fetchPoolProfiles(page: any, size: any, filter?: any, order_by?: any, profile_ids?: any[]): Promise<any>;
+        fetchPoolProfileLeaderboard({ server, logins, profile_ids, name_like, is_exact_match, is_mam, currency, runtime, growth_range_from, growth_range_to, }: {
+            server: any;
+            logins: any;
+            profile_ids: any;
+            name_like: any;
+            is_exact_match: any;
+            is_mam: any;
+            currency: any;
+            runtime: any;
+            growth_range_from: any;
+            growth_range_to: any;
+        }, sort_by: any): Promise<any>;
+        getWidgetData(profile_id: number, chart_name: string): Promise<unknown>;
+        getAccountSummary(profile_id: number): Promise<unknown>;
+        getPoolProfileDeals(payload: any): Promise<unknown>;
+        countDeals(payload: any): Promise<unknown>;
+        getProfilePositions(payload: any): Promise<unknown>;
+        countPositions(payload: any): Promise<unknown>;
+        checkDuplicatePoolName(name: string): Promise<unknown>;
+        getPositionsInvestWallet({ payload, }: {
+            payload: {
+                investWalletId: string;
+                symbol?: string[];
+                trade_action?: string[];
+                from_time?: string;
+                to_time?: string;
+                page: number;
+                size: number;
+                order_by?: string;
+                order_direction?: string;
+            };
+        }): Promise<unknown>;
+        getCountPositionInvestWallet(idWallet: string, state: string): Promise<unknown>;
+        updatePositionListSocketInvestWallet(payload: import('./stores/poolProfile').IPositionInvestWallet[]): void;
+        getPoolPositions(params: {
+            server: string;
+            login: number;
+            page: number;
+            size: number;
+            order_by?: {
+                [key: string]: string;
+            };
+            state?: "open" | "closed";
+        }): Promise<unknown>;
+        updatePoolProfileLiveUpdate(payload: any): void;
+        exportFundManagerDetails(params: {
+            pool_id: number;
+            start_date?: string;
+            end_date?: string;
+        }): Promise<unknown>;
+    }>;
+    useInvestWalletStore: import('pinia').StoreDefinition<"invest_wallet", {
+        investWallets: any[];
+        selectedWallet: {};
+        poolSummary: {};
+        investWalletsProfitLoss: {
+            profit: {
+                [key: string | number]: any;
+            };
+            loss: {
+                [key: string | number]: any;
+            };
+            pl: {
+                [key: string | number]: any;
+            };
+        };
+    }, {
+        getInvestWalletById: (state: {
+            investWallets: any[];
+            selectedWallet: {};
+            poolSummary: {};
+            investWalletsProfitLoss: {
+                profit: {
+                    [key: string | number]: any;
+                };
+                loss: {
+                    [key: string | number]: any;
+                };
+                pl: {
+                    [key: string | number]: any;
+                };
+            };
+        } & import('pinia').PiniaCustomStateProperties<{
+            investWallets: any[];
+            selectedWallet: {};
+            poolSummary: {};
+            investWalletsProfitLoss: {
+                profit: {
+                    [key: string | number]: any;
+                };
+                loss: {
+                    [key: string | number]: any;
+                };
+                pl: {
+                    [key: string | number]: any;
+                };
+            };
+        }>) => (id: number) => any;
+        getInvestWalletsByFilterAndOrder: (state: {
+            investWallets: any[];
+            selectedWallet: {};
+            poolSummary: {};
+            investWalletsProfitLoss: {
+                profit: {
+                    [key: string | number]: any;
+                };
+                loss: {
+                    [key: string | number]: any;
+                };
+                pl: {
+                    [key: string | number]: any;
+                };
+            };
+        } & import('pinia').PiniaCustomStateProperties<{
+            investWallets: any[];
+            selectedWallet: {};
+            poolSummary: {};
+            investWalletsProfitLoss: {
+                profit: {
+                    [key: string | number]: any;
+                };
+                loss: {
+                    [key: string | number]: any;
+                };
+                pl: {
+                    [key: string | number]: any;
+                };
+            };
+        }>) => (filter: any, order: any) => any[];
+    }, {
+        fetchInvestWallets(params: any): Promise<unknown>;
+        fetchOneInvestWallet(id: number): Promise<any>;
+        fetchPoolSummaryWallet(params: any): Promise<any>;
+        fetchInvestWalletProfitLoss(ids?: number[], from_time?: Date, to_time?: Date): Promise<any>;
+        fetchProfitLossHistory(params: any): Promise<any>;
+        createInvestWallet(data: any): Promise<any>;
+        transferOutInvestWallet(id: number, amount: number, destination_id: number): Promise<any>;
+        partialClosePosition(position_id: number, invest_wallet_id: string): Promise<any>;
+        fetchInvestDeals(params: object): Promise<any>;
+        fetchAttachedWallets(params: object): Promise<any>;
+        getTotalInvestWallet(): Promise<any>;
+        getInvestWalletBalanceChanges(params: object): Promise<any>;
+    }>;
+    useConversionRateStore: import('pinia').StoreDefinition<"conversion_rate", {
+        conversion_rates: {
+            [key: string]: any;
+        };
+    }, {}, {
+        fetchConversionRate(from_currency: string, to_currency: string, date?: string): Promise<any>;
+        fetchConversionRates(pairs: string[][]): Promise<any>;
+        fetchCryptoConversionRate(from_currency: string, to_currency: string): Promise<any>;
+    }>;
+    useCommissionProfileStore: import('pinia').StoreDefinition<"commission_profile", {
+        commission_profiles: any[];
+        editing_commission_profile: {};
+    }, {}, {
+        fetchCommissionProfile(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        getCommissionProfileDetailInfo(id: number): Promise<any>;
+        createCommissionProfile(payload: any): Promise<any>;
+        cloneCommissionProfile(id: number, payload: any): Promise<any>;
+        updateCommissionProfile(id: number, payload: any): Promise<any>;
+        deleteCommissionProfile(id: number): Promise<any>;
+        getAllCommissionProfiles(): Promise<any>;
+    }>;
+    useRoleSetStore: import('pinia').StoreDefinition<"role_sets", {}, {}, {
+        fetchRoles(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        createRole(payload: any): Promise<any>;
+        updateRole(id: number, payload: any): Promise<any>;
+        deleteRole(id: number): Promise<any>;
+        cloneRole(id: number): Promise<any>;
+    }>;
+    useIBStore: import('pinia').StoreDefinition<"ib", {
+        ibs: any[];
+        selected_ib: {};
+    }, {}, {
+        getIB(payload?: any): Promise<any>;
+        getIBByID(id: string): Promise<any>;
+        createIB(payload: any): Promise<any>;
+        updateIB(id: string, payload: any): Promise<any>;
+        deleteIB(id: string): Promise<any>;
+        assginAccountToIB(id: string, payload: any): Promise<any>;
+        unassginAccountFromIB(payload: any): Promise<any>;
+        assginLeadToIB(id: string, payload: any): Promise<any>;
+        unassginLeadFromIB(payload: any): Promise<any>;
+        assginClientToIB(id: string, payload: any): Promise<any>;
+        unassginClientFromIB(payload: any): Promise<any>;
+        bulkUpdateIBState(payload: any): Promise<any>;
+        getTotalCommissions(id: number, params: any): Promise<any>;
+        getTotalCommissionsSummary(id: number, params: import('./common/types').ITotalSummaryParams): Promise<import('./common/types').ITotalSummary>;
+        getDailyStatistic(id: number, params: any): Promise<any>;
+    }>;
+    useDepartmentStore: import('pinia').StoreDefinition<"departments", {}, {}, {
+        fetchDepartments(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        createDepartment(payload: any): Promise<any>;
+        updateDepartment(id: number, payload: any): Promise<any>;
+        deleteDepartment(id: number): Promise<any>;
+        changeStateDepartment(id: number, state: string): Promise<any>;
+    }>;
+    useReportFilterStore: import('pinia').StoreDefinition<"report_filters", {
+        report_filters: any[];
+    }, {}, {
+        getReportFilter(): Promise<any>;
+        getReportFilterById(id: any): Promise<any>;
+        createReportFilter(payload: any): Promise<any>;
+        updateReportFilter(id: any, payload: any): Promise<any>;
+        deleteReportFilter(id: any): Promise<any>;
+    }>;
+    useEmployeeStore: import('pinia').StoreDefinition<"employee", {}, {}, {
+        createEmployee(payload: any): Promise<any>;
+        updateEmployee(id: any, payload: any): Promise<any>;
+        deleteEmployee(id: any, payload?: any): Promise<any>;
+        resendInvitation(id: any): Promise<any>;
+        updateEmployeeComment(id: any, payload: any): Promise<any>;
+        changeEmployeeState(id: any, payload: any): Promise<any>;
+        updateGrantRoleAdmin(employeeId: string | number): Promise<unknown>;
+        transferSuperAdminRole(fromId: string | number, toId: string | number): Promise<unknown>;
+        fetchListAdminRole(): Promise<unknown>;
+        checkEmployeeLinked(id: string | number): Promise<any>;
+    }>;
+    useActivityLogStore: import('pinia').StoreDefinition<"activity_log", {
+        activity_log_ids: any[];
+        activity_logs: any[];
+    }, {}, {
+        getActivityLogIds(content_type: string, content_id: number, message: string): Promise<any>;
+        getActivityLogs(content_type: string, content_id: number, message: string, page: number, size: number): Promise<any>;
+    }>;
+    useTradeServerStore: import('pinia').StoreDefinition<"tradeServer", {
+        tradeServers: any[];
+    }, {}, {
+        fetchTradeServers(payload?: any): Promise<any>;
+        getTradeServer(id: number): Promise<any>;
+        createTradeServer(payload: any): Promise<any>;
+        updateTradeServer(id: number, payload: any): Promise<any>;
+        deleteTradeServer(id: number, payload: any): Promise<any>;
+        getCategories(payload: any): Promise<any>;
+        sendOtpPasswordTradeServer(server_id: number): Promise<unknown>;
+        verifyOtpRetrievePassword(code: string, server_id: number): Promise<unknown>;
+    }>;
+    useFolderStore: import('pinia').StoreDefinition<"folder", {
+        folders: any[];
+        public_folders: any[];
+        attachments: any[];
+    }, {}, {
+        fetchFolders(page: any, size: any, filter: any, order_by: any): Promise<any>;
+        createFolder(payload: any): Promise<any>;
+        updateFolder(folder_id: number, payload: any): Promise<any>;
+        getAttachments(folder_id: number): Promise<any>;
+        getPublicFolders(): Promise<any>;
+        addAttachments(folder_id: number, payload: any): Promise<any>;
+        updateAttachment(folder_id: number, attachment_id: number, payload: any): Promise<any>;
+        deleteAttachment(folder_id: number, attachment_id: number): Promise<any>;
+        deleteFolder(folder_id: number): Promise<any>;
+    }>;
+    useNotificationStore: import('pinia').StoreDefinition<"notification", {
+        notifications: any[];
+    }, {}, {
+        clearNotifications(): void;
+        addNotification(notification: any): void;
+    }>;
+    useContentTypeStore: import('pinia').StoreDefinition<"content-type", {
+        content_types: any[];
+    }, {
+        clientKycSchema(): unknown[];
+        clientKycDocuments(): unknown[];
+    }, {
+        fetchContentTypes(): Promise<any>;
+        fetchContentTypeByName(name: string): Promise<any>;
+        updateContentType(id: string, payload: any): Promise<any>;
+    }>;
+    useGamificationCampaignStore: import('pinia').StoreDefinition<"gamification_campaign", {
+        campaigns: any[];
+        editing_campaign: {};
+    }, {}, {
+        getAllCampaigns(payload: any): Promise<any>;
+        updateCampaign(payload: any): Promise<any>;
+        createCampaign(payload: any): Promise<any>;
+        deleteCampaign(id: string): Promise<any>;
+        getCampaignById(id: string): Promise<any>;
+    }>;
+    usePurchasesStore: import('pinia').StoreDefinition<"purchases", {
+        purchases: any[];
+        selectedPurchase: {};
+        purchasedInfo: Record<string, any> | null;
+    }, {}, {
+        fetchPurchases(payload?: {
+            page?: number;
+            size?: number;
+            filter?: any;
+            order_by?: any;
+            from_time?: any;
+            to_time?: any;
+        }): Promise<unknown>;
+        calculatePurchase(payload: import('./services/ClientSDK/purchase/type').CalculatePurchasePayload): Promise<unknown>;
+        createPurchase(payload: import('./services/ClientSDK/purchase/type').CreatePurchasePayload): Promise<import('./services/ClientSDK/purchase/type').CreatePurchasePayload | null>;
+        updatePurchase(id: string | number, payload: any): Promise<unknown>;
+        purchaseNow(purchaseId: number, payload: import('./services/ClientSDK/purchase/type').PurchaseNowPayload): Promise<unknown>;
+        purchaseNowAnonymous(payload: import('./services/ClientSDK/purchase/type').PurchaseNowPayload): Promise<unknown>;
+        getPurchaseByUUID(uuid: string): Promise<unknown>;
+        createPurchaseForRequest(request_id: string): Promise<unknown>;
+    }>;
+    usePaymentStore: import('pinia').StoreDefinition<"payment", {
+        listPayments: any[];
+        availableCurrenciesByMethod: Record<string, string[] | undefined>;
+    }, {}, {
+        payments(payload: any): Promise<any>;
+        createPayment(payload: any): Promise<any>;
+        uploadProofOfPayment(payload: any): Promise<any>;
+        approvePayment(payload: any): Promise<any>;
+        rejectPayment(payload: any): Promise<any>;
+        autoCompleted(payload: any): Promise<any>;
+        sumTotalDepositWithdrawal(payload: any): Promise<any>;
+        getFundingSummaries(payload: any): Promise<any>;
+        payInvoice(id: string, payload: {
+            source: string;
+            source_id: number;
+        }): Promise<any>;
+        sendInvoiceEmail(id: string): Promise<any>;
+        getAvailableCurrencies(payload: {
+            payment_method: string;
+        }): Promise<unknown>;
+        loadAvailableCurrencies(method: string, options?: {
+            force?: boolean;
+            map?: (raw: any) => string;
+        }): Promise<string[]>;
+    }>;
+    useTradeBattleStore: import('pinia').StoreDefinition<"trade_battle", import('./stores/tradeBattle').TradeBattleStates, {}, {
+        createTradeBattle(payload: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleBody): Promise<import('axios').AxiosResponse<import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleBody, any, {}, any>>;
+        editTradeBattle(payload: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleBody, uuid: string): Promise<import('axios').AxiosResponse<import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleBody, any, {}, any>>;
+        joinTradeBattle(payload: import('./services/ClientSDK/purchase/type').CreatePurchasePayload): Promise<import('axios').AxiosResponse<import('./services/ClientSDK/purchase/type').PurchaseData, any, {}, any>>;
+        reJoinBattle(payload: import('./services/ClientSDK/purchase/type').CreatePurchasePayload): Promise<import('axios').AxiosResponse<import('./services/ClientSDK/purchase/type').PurchaseData, any, {}, any>>;
+        purchaseNow(data: import('./services/ClientSDK/purchase/type').PurchaseNowPayload, purchase_id: number): Promise<import('axios').AxiosResponse<import('./services/ClientSDK/tradeBattle/tradeBattle.type').PurchaseNowResponse, any, {}, any>>;
+        getTradeBattleList({ state, category_uuid, isChangeStore, }: {
+            state?: string;
+            category_uuid: string;
+            isChangeStore?: boolean;
+        }): Promise<import('axios').AxiosResponse<import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleBody[], any, {}, any>>;
+        startBattle({ request_type, ...rest }: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleActionRequest): Promise<any>;
+        completeBattle({ request_type, ...rest }: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleActionRequest): Promise<any>;
+        cancelBattle({ request_type, ...rest }: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleActionRequest): Promise<any>;
+        commentBattle({ request_type, ...rest }: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeBattleCommentRequest): Promise<any>;
+        getTradeHistoryByBattleOrAccount(payload: import('./services/ClientSDK/tradeBattle/tradeBattle.type').TradeHistoryParams): Promise<any>;
+        getRanking(payload: {
+            product_id: any;
+        }): Promise<any>;
+        getTradedLot(id: string, payload?: {
+            from_date: string;
+            to_date: string;
+        }): Promise<any>;
+        getYesterdayAccountBalance(payload: {
+            product_id: any;
+            logins?: any;
+        }): Promise<any>;
+        getBattleNicknameAndProfile(payload: {
+            product_id: any;
+            logins?: any;
+        }): Promise<any>;
+        getCurrentAttendees(state?: string): Promise<any>;
+        getRankingForAccounts(): Promise<any>;
+        checkNickNameAccount(payload: {
+            nick_name: any;
+        }): Promise<any>;
+        getListAccountBattle(payload: any): Promise<any>;
+        fetchListBattleForRanking(payload: any): Promise<any>;
+        exportDealCSV(payload: any): Promise<any>;
+        exportCustom(payload: any, headers: any, responseType?: any): Promise<any>;
+    }>;
+    useNotificationCenter: import('pinia').StoreDefinition<"notification_center", {
+        notifications: any[];
+        unreadCount: number;
+        notificationsUnread: any[];
+    }, {}, {
+        createNotificationTemplate(payload: FormData): Promise<any>;
+        updateNotificationTemplate(payload: FormData, id: string | number): Promise<any>;
+        updateNotificationTemplateState(id: string | number, state: "enable" | "disable"): Promise<any>;
+        deleteNotificationTemplate(id: string | number): Promise<any>;
+        sendNotification(payload: import('./services/ClientSDK/notificationCenter/NotificationCenter.types').SendNotificationRequest): Promise<any>;
+        updateNotification(payload: import('./services/ClientSDK/notificationCenter/NotificationCenter.types').SendNotificationRequest, id: string | number): Promise<any>;
+        deleteNotification(id: string | number): Promise<any>;
+        deleteNotificationuser(id: string | number): Promise<any>;
+        markAsRead(ids: number[]): Promise<any>;
+        fetchCountNotificationUnread(): Promise<any>;
+        fetchNotificationsUnread(page: number, size: number, filter: any, order_by: any): Promise<any>;
+        addNotificationUnread(notification: any): void;
+    }>;
+    useNewsStore: import('pinia').StoreDefinition<"news_store", {
+        newsData: any[];
+    }, {}, {
+        createNews(payload: {
+            news: import('./common/types').CreateNewsRequest;
+        } | import('./common/types').CreateNewsDraft): Promise<any>;
+        updateNews(id: string | number, payload: {
+            news: import('./common/types').CreateNewsRequest;
+        }): Promise<any>;
+        destroyNews(id: string | number): Promise<any>;
+        uploadBannerImage(id: any, payload: any): Promise<any>;
+        getNews(payload: import('./common/types').GetNewsPayload): Promise<any>;
+    }>;
+    useBattleNotificationStore: import('pinia').StoreDefinition<"battle_notification", {
+        notifications: any[];
+    }, {}, {
+        clearNotifications(): void;
+        addNotification(notification: any): void;
+    }>;
+    $resetAllStates: () => void;
+    useLiveNotificationStore: import('pinia').StoreDefinition<"live_notification", import('./common/types').NotificationState, {}, {
+        clearLiveNotifications(): void;
+        addLiveNotification(notification: import('./common/types').NotificationType): void;
+    }>;
+    useContactStore: import('pinia').StoreDefinition<"contact", {
+        contact: any;
+    }, {}, {
+        getContatList(): Promise<unknown>;
+        getContactListById(id: any): Promise<unknown>;
+        createContactList(payload: any): Promise<unknown>;
+        updateContactList(id: any, data: any): Promise<unknown>;
+        deleteContactList(id: any): Promise<unknown>;
+    }>;
+    useNotesStore: import('pinia').StoreDefinition<"notes", {}, {}, {
+        createNotes(payload: {
+            object_id: number;
+            object_type: string;
+            subject: string;
+            entry_strategy?: string;
+            exit_strategy?: string;
+            comments?: string;
+            tags?: string;
+            opening_the_trade?: File | any;
+            closing_the_trade?: File | any;
+            extra_data?: any;
+        } | any, options?: any): Promise<unknown>;
+        putNotes(payload: any, options?: any): Promise<unknown>;
+        deleteNotes(ids: any): Promise<unknown>;
+    }>;
+    useCaptchaStore: import('pinia').StoreDefinition<"captcha", {}, {}, {
+        verifyRecaptcha(captchaToken: string): Promise<any>;
+    }>;
+    useAddonStore: import('pinia').StoreDefinition<"addon", {
+        categories: import('./common/types').IAddonCategory[];
+    }, {
+        getCategories(): import('./common/types').IAddonCategory[];
+        getAllAddons(): import('./common/types').IAddon[];
+        getAddonStatus: () => (addon: import('./common/types').IAddon, currency?: string) => string;
+    }, {
+        fetchAddonsByCategoryIds(categoryIds: number[]): Promise<any>;
+    }>;
+    useReportStore: import('pinia').StoreDefinition<"report", {}, {}, {
+        downloadProfitLossReport(payload: any): Promise<any>;
+        downloadVolumeReport(payload: any): Promise<any>;
+        downloadTopTradingReport(payload: any): Promise<any>;
+        downloadTopTradersReport(payload: any): Promise<any>;
+        downloadTransactionsReport(payload: any): Promise<any>;
+        downloadDPWPITRReport(payload: any): Promise<any>;
+        downloadIBCommissionTransactionsReport(payload: any): Promise<any>;
+        downloadLeadsAndClientsReport(payload: any): Promise<any>;
+        downloadNewLeadsDailyReport(payload: any): Promise<any>;
+        downloadReferAFriendReport(payload: any): Promise<any>;
+        downloadIBDetailedTradingPerAccReport(payload: any): Promise<any>;
+        downloadIBTotalDetailedTradingInfoReport(payload: any): Promise<any>;
+        downloadIBTotalTradedVolumeReport(payload: any): Promise<any>;
+        downloadIBSummaryReport(payload: any): Promise<any>;
+        downloadIBReport(payload: any): Promise<any>;
+        downloadWalletDetailsReport(payload: any): Promise<any>;
+        downloadTotalIBCommissionReport(payload: any): Promise<any>;
+    }>;
+    useAdvertisingStore: import('pinia').StoreDefinition<"advertising", {
+        banners: import('./stores/advertising').AdvertisingItem[];
+        popups: import('./stores/advertising').AdvertisingItem[];
+        bannerPagination: import('./stores/advertising').AdvertisingPagination;
+        popupPagination: import('./stores/advertising').AdvertisingPagination;
+        loading: boolean;
+    }, {
+        enabledBanners: (state: {
+            banners: {
+                id: number;
+                content_type: import('./common/types').AdvertisingType;
+                state?: string;
+                metadata: {
+                    title: string;
+                    status?: import('./common/types').AdvertisingStatus;
+                    purpose: import('./common/types').AdvertisingPurpose;
+                    priority?: number | null;
+                    start_date?: string | null;
+                    end_date?: string | null;
+                    contact_list?: string[];
+                    templates?: Record<string, import('./common/types').AdvertisingTemplateVariant>;
+                    frequency?: import('./common/types').AdvertisingFrequency;
+                    cooldown?: {
+                        enabled: boolean;
+                        time_seconds: number;
+                    };
+                };
+                attachments?: any[];
+                user_id?: number;
+                created_at?: string;
+                updated_at?: string;
+            }[];
+            popups: {
+                id: number;
+                content_type: import('./common/types').AdvertisingType;
+                state?: string;
+                metadata: {
+                    title: string;
+                    status?: import('./common/types').AdvertisingStatus;
+                    purpose: import('./common/types').AdvertisingPurpose;
+                    priority?: number | null;
+                    start_date?: string | null;
+                    end_date?: string | null;
+                    contact_list?: string[];
+                    templates?: Record<string, import('./common/types').AdvertisingTemplateVariant>;
+                    frequency?: import('./common/types').AdvertisingFrequency;
+                    cooldown?: {
+                        enabled: boolean;
+                        time_seconds: number;
+                    };
+                };
+                attachments?: any[];
+                user_id?: number;
+                created_at?: string;
+                updated_at?: string;
+            }[];
+            bannerPagination: {
+                page: number;
+                page_size: number;
+                total: number;
+            };
+            popupPagination: {
+                page: number;
+                page_size: number;
+                total: number;
+            };
+            loading: boolean;
+        } & import('pinia').PiniaCustomStateProperties<{
+            banners: import('./stores/advertising').AdvertisingItem[];
+            popups: import('./stores/advertising').AdvertisingItem[];
+            bannerPagination: import('./stores/advertising').AdvertisingPagination;
+            popupPagination: import('./stores/advertising').AdvertisingPagination;
+            loading: boolean;
+        }>) => import('./stores/advertising').AdvertisingItem[];
+        enabledPopups: (state: {
+            banners: {
+                id: number;
+                content_type: import('./common/types').AdvertisingType;
+                state?: string;
+                metadata: {
+                    title: string;
+                    status?: import('./common/types').AdvertisingStatus;
+                    purpose: import('./common/types').AdvertisingPurpose;
+                    priority?: number | null;
+                    start_date?: string | null;
+                    end_date?: string | null;
+                    contact_list?: string[];
+                    templates?: Record<string, import('./common/types').AdvertisingTemplateVariant>;
+                    frequency?: import('./common/types').AdvertisingFrequency;
+                    cooldown?: {
+                        enabled: boolean;
+                        time_seconds: number;
+                    };
+                };
+                attachments?: any[];
+                user_id?: number;
+                created_at?: string;
+                updated_at?: string;
+            }[];
+            popups: {
+                id: number;
+                content_type: import('./common/types').AdvertisingType;
+                state?: string;
+                metadata: {
+                    title: string;
+                    status?: import('./common/types').AdvertisingStatus;
+                    purpose: import('./common/types').AdvertisingPurpose;
+                    priority?: number | null;
+                    start_date?: string | null;
+                    end_date?: string | null;
+                    contact_list?: string[];
+                    templates?: Record<string, import('./common/types').AdvertisingTemplateVariant>;
+                    frequency?: import('./common/types').AdvertisingFrequency;
+                    cooldown?: {
+                        enabled: boolean;
+                        time_seconds: number;
+                    };
+                };
+                attachments?: any[];
+                user_id?: number;
+                created_at?: string;
+                updated_at?: string;
+            }[];
+            bannerPagination: {
+                page: number;
+                page_size: number;
+                total: number;
+            };
+            popupPagination: {
+                page: number;
+                page_size: number;
+                total: number;
+            };
+            loading: boolean;
+        } & import('pinia').PiniaCustomStateProperties<{
+            banners: import('./stores/advertising').AdvertisingItem[];
+            popups: import('./stores/advertising').AdvertisingItem[];
+            bannerPagination: import('./stores/advertising').AdvertisingPagination;
+            popupPagination: import('./stores/advertising').AdvertisingPagination;
+            loading: boolean;
+        }>) => import('./stores/advertising').AdvertisingItem[];
+    }, {
+        fetchBanners(options?: import('./stores/advertising').AdvertisingFetchOptions): Promise<any>;
+        fetchPopups(options?: import('./stores/advertising').AdvertisingFetchOptions): Promise<any>;
+        create(metadata: Partial<import('./stores/advertising').AdvertisingMetadata>, contentType: import('./common/types').AdvertisingType, state?: string, withAttachments?: boolean): Promise<any>;
+        update(id: number | string, metadata: Partial<import('./stores/advertising').AdvertisingMetadata>, contentType: import('./common/types').AdvertisingType, state?: string, withAttachments?: boolean): Promise<any>;
+        destroy(id: number | string, contentType: import('./common/types').AdvertisingType): Promise<any>;
+        toggle(id: number | string, contentType: import('./common/types').AdvertisingType, state: import('./common/types').AdvertisingStatus): Promise<any>;
+        reorder(contentType: import('./common/types').AdvertisingType, orderedIds: Array<number | string>): Promise<any[]>;
+        invalidate(contentType: import('./common/types').AdvertisingType): Promise<any>;
+    }>;
+};