rain-sdk-v2 1.0.0

package/dist/api/orders.d.ts

@@ -0,0 +1,8 @@
+import { ApiConfig, ApiResponse, GetUserOrdersParams, OrderBookParams, GetUserOrderByPoolIdParams, OrdersListingByPoolParams } from './types.js';
+export declare function getUserOrders(params: GetUserOrdersParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getOrderBook(params: OrderBookParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getUserOrderByPoolId(params: GetUserOrderByPoolIdParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getOrdersListingByPool(params: OrdersListingByPoolParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getOrderById(params: {
+    orderId: string;
+}, config: ApiConfig): Promise<ApiResponse>;

package/dist/api/orders.js

@@ -0,0 +1,40 @@
+import { buildHeaders, buildQuery, handleResponse } from './helpers.js';
+export async function getUserOrders(params, config) {
+    const qs = buildQuery({ filter: params.filter, limit: params.limit, offset: params.offset });
+    const res = await fetch(`${config.apiUrl}/orders/get-user-orders${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getOrderBook(params, config) {
+    const qs = buildQuery({ pool: params.pool, limit: params.limit, offset: params.offset });
+    const res = await fetch(`${config.apiUrl}/orders/order-book${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getUserOrderByPoolId(params, config) {
+    const qs = buildQuery({ filter: params.filter });
+    const res = await fetch(`${config.apiUrl}/orders/get-user-order-by-poolId/${encodeURIComponent(params.poolId)}${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getOrdersListingByPool(params, config) {
+    const qs = buildQuery({ pool: params.pool, limit: params.limit, offset: params.offset });
+    const res = await fetch(`${config.apiUrl}/orders/orders-listing-by-pool${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getOrderById(params, config) {
+    const res = await fetch(`${config.apiUrl}/orders/get-order/${encodeURIComponent(params.orderId)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/points.d.ts

@@ -0,0 +1,5 @@
+import { ApiConfig, ApiResponse, AddUserPointsParams, UserOnboardingParams, PointsGraphParams } from './types.js';
+export declare function addUserPoints(params: AddUserPointsParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getUserPoints(config: ApiConfig): Promise<ApiResponse>;
+export declare function userSuccessfulOnboarding(params: UserOnboardingParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getUserPointsGraph(params: PointsGraphParams, config: ApiConfig): Promise<ApiResponse>;

package/dist/api/points.js

@@ -0,0 +1,32 @@
+import { buildHeaders, buildQuery, handleResponse } from './helpers.js';
+export async function addUserPoints(params, config) {
+    const res = await fetch(`${config.apiUrl}/points/add-user-points`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getUserPoints(config) {
+    const res = await fetch(`${config.apiUrl}/points/get-user-points`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function userSuccessfulOnboarding(params, config) {
+    const res = await fetch(`${config.apiUrl}/points/user-succesfull-onboarding`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getUserPointsGraph(params, config) {
+    const qs = buildQuery({ range: params.range });
+    const res = await fetch(`${config.apiUrl}/points/get-user-points-graph${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/poolReviews.d.ts

@@ -0,0 +1,4 @@
+import { ApiConfig, ApiResponse, AddReviewParams } from './types.js';
+export declare function addReview(params: AddReviewParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getUserReviews(config: ApiConfig): Promise<ApiResponse>;
+export declare function getPoolsByCreatorReviews(config: ApiConfig): Promise<ApiResponse>;

package/dist/api/poolReviews.js

@@ -0,0 +1,23 @@
+import { buildHeaders, handleResponse } from './helpers.js';
+export async function addReview(params, config) {
+    const res = await fetch(`${config.apiUrl}/pool-reviews/add-review`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getUserReviews(config) {
+    const res = await fetch(`${config.apiUrl}/pool-reviews/user-reviews`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getPoolsByCreatorReviews(config) {
+    const res = await fetch(`${config.apiUrl}/pool-reviews/pools-by-creator`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/pools.d.ts

@@ -0,0 +1,41 @@
+import { ApiConfig, ApiResponse, PublicPoolsParams, PrivatePoolsParams, PoolListingByCreatorParams, VerifyAccessCodeParams, PoolTotalParticipantsParams, SearchPoolParams, RelatedPoolsParams, UpdateStreamingParams, UpdatePoolResolutionTimeParams, FindPoolFallbackParams, SignOraclesExtendTimeParams } from './types.js';
+export declare function accessPool(params: {
+    poolId: string;
+    accessCode: string;
+}, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPublicPools(params: PublicPoolsParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPrivatePools(params: PrivatePoolsParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPoolById(params: {
+    id: string;
+}, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPoolByContractAddress(params: {
+    contractAddress: string;
+}, config: ApiConfig): Promise<ApiResponse>;
+export declare function searchPool(params: SearchPoolParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function verifyAccessCode(params: VerifyAccessCodeParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPoolListingByCreator(params: PoolListingByCreatorParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function searchPoolById(params: {
+    poolId: string;
+}, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPoolTotalParticipants(params: PoolTotalParticipantsParams, config: ApiConfig): Promise<ApiResponse<{
+    totalParticipants: number;
+}>>;
+export declare function getTotalPoolsByUser(config: ApiConfig): Promise<ApiResponse<{
+    totalPoolsCreated: number;
+}>>;
+export declare function signOraclesExtendTime(params: SignOraclesExtendTimeParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getTotalPredictionsByUser(config: ApiConfig): Promise<ApiResponse<{
+    totalPredictions: number;
+}>>;
+export declare function updateStreaming(params: UpdateStreamingParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getAllPoolsCount(config: ApiConfig): Promise<ApiResponse<{
+    openPoolsCount: number;
+}>>;
+export declare function getRelatedPools(params: RelatedPoolsParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getPoolResolutionHistory(params: {
+    poolId: string;
+    subPool: string;
+}, config: ApiConfig): Promise<ApiResponse>;
+export declare function updatePoolResolutionTime(params: UpdatePoolResolutionTimeParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function findPoolFallback(params: FindPoolFallbackParams, config: ApiConfig): Promise<ApiResponse>;
+export declare function getFeaturedPools(config: ApiConfig): Promise<ApiResponse>;

package/dist/api/pools.js

@@ -0,0 +1,149 @@
+import { buildHeaders, buildQuery, handleResponse } from './helpers.js';
+export async function accessPool(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/access-pool/${encodeURIComponent(params.poolId)}/${encodeURIComponent(params.accessCode)}`, { method: 'GET', headers: buildHeaders(config) });
+    return handleResponse(res);
+}
+export async function getPublicPools(params, config) {
+    const qs = buildQuery({ limit: params.limit, offset: params.offset, tag: params.tag, sortBy: params.sortBy, status: params.status });
+    const res = await fetch(`${config.apiUrl}/pools/public-pools${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getPrivatePools(params, config) {
+    const qs = buildQuery({ limit: params.limit, offset: params.offset, tag: params.tag, status: params.status });
+    const res = await fetch(`${config.apiUrl}/pools/pools-private${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getPoolById(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/pool/${encodeURIComponent(params.id)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getPoolByContractAddress(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/poolByContractAddress/${encodeURIComponent(params.contractAddress)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function searchPool(params, config) {
+    const qs = buildQuery({ question: params.question });
+    const res = await fetch(`${config.apiUrl}/pools/search-pool${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function verifyAccessCode(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/verify-access-code`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getPoolListingByCreator(params, config) {
+    const qs = buildQuery({ limit: params.limit, offset: params.offset, filter: params.filter });
+    const res = await fetch(`${config.apiUrl}/pools/pool-listing-by-creator${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function searchPoolById(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/search/${encodeURIComponent(params.poolId)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getPoolTotalParticipants(params, config) {
+    const qs = buildQuery({ poolId: params.poolId });
+    const res = await fetch(`${config.apiUrl}/pools/pool-total-participants${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getTotalPoolsByUser(config) {
+    const res = await fetch(`${config.apiUrl}/pools/total-pools-created-by-user`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function signOraclesExtendTime(params, config) {
+    const qs = buildQuery({ contractAddress: params.contractAddress, walletAddress: params.walletAddress });
+    const res = await fetch(`${config.apiUrl}/pools/sign-oracles-extend-time${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getTotalPredictionsByUser(config) {
+    const res = await fetch(`${config.apiUrl}/pools/total-predictions-by-user`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function updateStreaming(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/update-streaming`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getAllPoolsCount(config) {
+    const res = await fetch(`${config.apiUrl}/pools/get-all-pools-count`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getRelatedPools(params, config) {
+    const qs = buildQuery({ limit: params.limit, offset: params.offset });
+    const res = await fetch(`${config.apiUrl}/pools/get-related-pools/${encodeURIComponent(params.poolId)}${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getPoolResolutionHistory(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/get-pool-resolution-history/${encodeURIComponent(params.poolId)}/${encodeURIComponent(params.subPool)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function updatePoolResolutionTime(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/update-pool-resolution-time`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function findPoolFallback(params, config) {
+    const res = await fetch(`${config.apiUrl}/pools/find-pool-fallback`, {
+        method: 'POST',
+        headers: buildHeaders(config, 'application/json'),
+        body: JSON.stringify(params),
+    });
+    return handleResponse(res);
+}
+export async function getFeaturedPools(config) {
+    const res = await fetch(`${config.apiUrl}/pools/get-featured-pools`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/priceData.d.ts

@@ -0,0 +1,2 @@
+import { ApiConfig, ApiResponse, PriceDataParams } from './types.js';
+export declare function getPriceData(params: PriceDataParams, config: ApiConfig): Promise<ApiResponse>;

package/dist/api/priceData.js

@@ -0,0 +1,9 @@
+import { buildHeaders, buildQuery, handleResponse } from './helpers.js';
+export async function getPriceData(params, config) {
+    const qs = buildQuery({ contractAddress: params.contractAddress, filter: params.filter });
+    const res = await fetch(`${config.apiUrl}/price-data/get-price-data${qs}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/rainBurn.d.ts

@@ -0,0 +1,3 @@
+import { ApiConfig, ApiResponse, RainBurnPerPoolParams } from './types.js';
+export declare function getTotalBurned(config: ApiConfig): Promise<ApiResponse>;
+export declare function getBurnPerPool(params: RainBurnPerPoolParams, config: ApiConfig): Promise<ApiResponse>;

package/dist/api/rainBurn.js

@@ -0,0 +1,15 @@
+import { buildHeaders, handleResponse } from './helpers.js';
+export async function getTotalBurned(config) {
+    const res = await fetch(`${config.apiUrl}/rain-token/total-burned`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}
+export async function getBurnPerPool(params, config) {
+    const res = await fetch(`${config.apiUrl}/rain-token/per-pool/${encodeURIComponent(params.poolId)}`, {
+        method: 'GET',
+        headers: buildHeaders(config),
+    });
+    return handleResponse(res);
+}

package/dist/api/types.d.ts

@@ -0,0 +1,292 @@
+export interface ApiConfig {
+    apiUrl: string;
+    accessToken?: string;
+}
+export interface ApiResponse<T = unknown> {
+    statusCode: number;
+    message: string;
+    data?: T;
+    details?: unknown;
+}
+export interface UserProfile {
+    _id: string;
+    walletAddress: string;
+    name?: string;
+    bio?: string;
+    profilePic?: string;
+    twitterLink?: string;
+    instagramLink?: string;
+    discordLink?: string;
+    telegramLink?: string;
+    facebookLink?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface UserProfileUpdateParams {
+    name?: string;
+    bio?: string;
+    profilePic?: string;
+    twitterLink?: string;
+    instagramLink?: string;
+    discordLink?: string;
+    telegramLink?: string;
+    facebookLink?: string;
+}
+export interface UserHistoryParams {
+    limit?: number;
+    offset?: number;
+}
+export interface UserHistoryItem {
+    action: string;
+    poolQuestion?: string;
+    poolToken?: Record<string, unknown>;
+    optionName?: string;
+    amount?: number;
+    txHash?: string;
+    createdAt?: string;
+}
+export interface UserHistoryResponse {
+    totalPoints: number;
+    followedTwitter: boolean;
+    joinedTomi: boolean;
+    history: UserHistoryItem[];
+    pagination: {
+        total: number;
+        offset: number;
+        limit: number;
+        totalPages: number;
+    };
+}
+export interface CreateCommentParams {
+    comment: string;
+    poolId: string;
+    parentCommentId?: string;
+}
+export interface CommentsListingParams {
+    poolId: string;
+    limit?: number;
+    offset?: number;
+}
+export interface UpdateCommentParams {
+    commentId: string;
+    comment: string;
+}
+export interface CommentCountParams {
+    poolId: string;
+}
+export interface PoolOption {
+    optionName: string;
+    optionImage?: string;
+    choiceIndex?: number;
+}
+export interface PoolToken {
+    tokenAddress: string;
+    tokenSymbol: string;
+    tokenDecimals: number;
+    tokenName?: string;
+    tokenLogo?: string;
+}
+export type PoolStatus = 'New' | 'Live' | 'Closing_Soon' | 'Pending_Finalization' | 'Waiting_for_Result' | 'Dispute_Window_Open' | 'Under_Dispute' | 'Appeal_Window_Open' | 'Under_Appeal' | 'Closed';
+export interface CreatePoolParams {
+    question: string;
+    isPrivate: boolean;
+    contractAddress: string;
+    poolTrxHash: string;
+    ipfsURL?: string;
+    poolDescription?: string;
+    tags?: string[];
+    options: {
+        optionName: string;
+    }[];
+    startDate: string;
+    endDate: string;
+    liquidityMax: number;
+}
+export interface PublicPoolsParams {
+    limit?: number;
+    offset?: number;
+    tag?: string;
+    sortBy?: string;
+    status?: PoolStatus;
+}
+export interface PrivatePoolsParams {
+    limit?: number;
+    offset?: number;
+    tag?: string;
+    status?: PoolStatus;
+}
+export interface PoolListingByCreatorParams {
+    limit: number;
+    offset: number;
+    filter?: 'privatePools' | 'publicPools';
+}
+export interface VerifyAccessCodeParams {
+    poolId: string;
+    accessCode: string;
+}
+export interface PoolTotalParticipantsParams {
+    poolId: string;
+}
+export interface SearchPoolParams {
+    question: string;
+}
+export interface RelatedPoolsParams {
+    poolId: string;
+    limit?: number;
+    offset?: number;
+}
+export interface UpdateStreamingParams {
+    poolId: string;
+    action: 'start' | 'stop';
+    videoStreamingID?: string;
+}
+export interface UpdatePoolResolutionTimeParams {
+    poolId: string;
+    resolutionTime?: string;
+}
+export interface FindPoolFallbackParams {
+    question: string;
+    isPrivate: boolean;
+    poolDescription?: string;
+    options: {
+        optionName: string;
+    }[];
+    startDate: string;
+    endDate: string;
+    tags?: string | string[];
+}
+export interface SignOraclesExtendTimeParams {
+    contractAddress: string;
+    walletAddress: string;
+}
+export interface UserTotalInvestmentParams {
+    poolId: string;
+}
+export interface OptionsTotalVolumeParams {
+    poolId: string;
+}
+export interface PoolActivityParams {
+    poolId: string;
+    limit?: number;
+    offset?: number;
+}
+export interface TopHoldersParams {
+    poolId: string;
+    subPoolIndex: number;
+    limit?: number;
+    offset?: number;
+}
+export interface UserInvestedPoolsParams {
+    limit?: number;
+    offset?: number;
+}
+export interface InvestmentVolumeGraphParams {
+    timeframe: 'day' | 'week' | 'month';
+}
+export interface UserPnlGraphParams {
+    timeframe: 'day' | 'week' | 'month' | 'all';
+}
+export interface TopWinnersLosersParams {
+    timeFilter?: 'all' | 'day' | 'week' | 'month';
+}
+export interface PnlByPoolIdParams {
+    poolId: string;
+}
+export interface PriceDataParams {
+    contractAddress: string;
+    filter?: '1H' | '6H' | '1D' | '1W' | '1M' | 'ALL';
+}
+export interface AddReviewParams {
+    poolId: string;
+    rating: number;
+    review?: string;
+}
+export interface CreateOrderParams {
+    pool: string;
+    quantity: number;
+    totalPrice: number;
+    externalID: string;
+    subPool: string;
+    subPoolIndex: number;
+    side: 1 | 2;
+    orderType: 'buy' | 'sell';
+}
+export interface GetUserOrdersParams {
+    filter?: 'open' | 'orderHistory';
+    limit?: number;
+    offset?: number;
+}
+export interface OrderBookParams {
+    pool: string;
+    limit?: number;
+    offset?: number;
+}
+export interface GetUserOrderByPoolIdParams {
+    poolId: string;
+    filter?: 'open' | 'orderHistory';
+}
+export interface OrdersListingByPoolParams {
+    pool: string;
+    limit?: number;
+    offset?: number;
+}
+export type PointsEventType = 'deposit' | 'withdraw' | 'trade' | 'add_liquidity' | 'open_market' | 'invite' | 'follow_twitter' | 'join_tomi';
+export interface AddUserPointsParams {
+    eventType: PointsEventType;
+    value: number;
+    points: number;
+    transactionHash: string;
+}
+export interface UserOnboardingParams {
+    points: number;
+    value: number;
+    eventType: 'invite';
+}
+export interface PointsGraphParams {
+    range?: 'day' | 'week' | 'month' | 'all';
+}
+export interface GetNotificationsParams {
+    page?: number;
+    limit?: number;
+    status?: 'all' | 'unread' | 'read';
+}
+export interface MarkNotificationAsReadParams {
+    id: string;
+}
+export interface CreateDisputeMessageParams {
+    pool: string;
+    role: 'creator' | 'disputer';
+    messageType: 'text' | 'image' | 'video' | 'file' | 'youtube';
+    file?: Blob | File;
+    evidence: {
+        question: string;
+        options: string[];
+        evidenceType: 'photo' | 'video' | 'pdf' | 'youtube';
+        description?: string;
+        source?: string;
+        youtubeUrl?: string;
+    };
+}
+export interface GetPoolDisputeConvoParams {
+    poolId: string;
+    subPool: string;
+    limit?: number;
+    offset?: number;
+}
+export interface FollowToggleParams {
+    userId: string;
+}
+export interface FollowCheckParams {
+    userId: string;
+}
+export interface FollowListParams {
+    userId: string;
+    page?: number;
+    limit?: number;
+}
+export interface FollowStatsParams {
+    userId: string;
+}
+export interface RainBurnPerPoolParams {
+    poolId: string;
+}

package/dist/api/types.js

@@ -0,0 +1,2 @@
+// ─── Common ───────────────────────────────────────────────────────────────────
+export {};

package/dist/api/users.d.ts

@@ -0,0 +1,15 @@
+import { ApiConfig, ApiResponse, UserProfile, UserProfileUpdateParams, UserHistoryParams, UserHistoryResponse } from './types.js';
+export declare function findUserByWalletAddress(params: {
+    walletAddress: string;
+}, config: ApiConfig): Promise<ApiResponse<UserProfile>>;
+export declare function updateUserProfile(params: UserProfileUpdateParams, config: ApiConfig): Promise<ApiResponse<UserProfile>>;
+export declare function getUserProfile(config: ApiConfig): Promise<ApiResponse<UserProfile>>;
+export declare function getUsersTotalCount(config: ApiConfig): Promise<ApiResponse<{
+    totalUsers: number;
+}>>;
+export declare function removeUserProfilePic(config: ApiConfig): Promise<ApiResponse<UserProfile>>;
+export declare function getUserHistory(params: UserHistoryParams, config: ApiConfig): Promise<ApiResponse<UserHistoryResponse>>;
+export declare function viewUserProfile(params: {
+    userId: string;
+}, config: ApiConfig): Promise<ApiResponse>;
+export declare function checkTokenExpiration(config: ApiConfig): Promise<ApiResponse>;