import { PublicKey } from '@solana/web3.js';
import { Wretch } from 'wretch';
import { Wretch as Wretch$1 } from 'wretch/types';

declare enum SugarMoneyApiEnvironmentsEnum {
    Staging = "staging",
    Development = "development",
    Preprod = "preprod",
    Production = "production",
    Local = "local"
}
declare const ApiUrls: {
    staging: string;
    development: string;
    preprod: string;
    production: string;
    local: string;
};
declare enum VersionEnum {
    V1 = "v1"
}
declare const WebsocketUrls: {
    staging: string;
    development: string;
    preprod: string;
    production: string;
};

type SugarMoneyLoginSignMessageType = (message: Uint8Array) => Promise<Uint8Array>;
type SugarMoneyLoginOptions = {
    signMessageFn: SugarMoneyLoginSignMessageType;
    baseUrl: string;
    publicKey: PublicKey;
    apiInstance: Wretch;
};
type SugarMoneyLoginResponseType = string;

type WretchWithFormData = Wretch & {
    formData: (data: FormData) => Wretch;
    query: (params: Record<string, unknown>) => Wretch;
};

type ApiRequestParams = {
    endpoint: string;
    data?: unknown;
    searchParams?: Record<string, unknown>;
    options: {
        isFormData?: boolean;
        method: 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete';
    };
    wretchInstance: Wretch$1;
    token?: string | null;
    environment: SugarMoneyApiEnvironmentsEnum;
};
type SugarMoneyApiMakeApiRequestType = <T>({ endpoint, data, options, searchParams, }: Omit<ApiRequestParams, 'wretchInstance' | 'environment'>) => Promise<T>;
type SugarMoneyApiCheckTransactionStatusType = (data: {
    signature: string;
}) => Promise<SugarMoneyTransactionStatusResponseType>;
type BuildModuleParamsType = {
    makeApiRequest: SugarMoneyApiMakeApiRequestType;
    apiInstance: WretchWithFormData;
    checkTransactionStatus?: SugarMoneyApiCheckTransactionStatusType;
};

declare const coinModule: ({ makeApiRequest, checkTransactionStatus }: BuildModuleParamsType) => {
    /**
     * Get the `SugarMoney` suffixed coin public key.
     *
     * Note this endpoint is rate limited.
     *
     * @returns The coin public key
     */
    getCoinPublicKey: () => Promise<string>;
    /**
     * Create a new coin. This coin will be created in our backend, not on chain.
     * To create it on chain call the `signTransaction` endpoint.
     *
     * Note this endpoint is rate limited.
     *
     * @param data - The data to create the coin
     * @returns The coin public key
     */
    postCoin: (data: SugarMoneyApiPostCoinRequestType) => Promise<SugarMoneyApiCoinResponseType>;
    /**
     * Use this to generate the coin metadata IPFS URL if you want to create a coin directly on chain, not using the API.
     */
    generateMetadataIpfsUrl: (data: SugarMoneyApiPostCoinRequestType) => Promise<string>;
    /**
       * Signs a transaction for a first buy. This will create the coin on chain and is
       * required if you want your coin to use a `SugarMoney` suffixed public key.
       *
       * Should only ever be called once per coin. Example usage:
       *
       * ```
       *  const sugarMoneyProgram = getSdk({ provider });
  
          const [createIxs] = await sugarMoneyProgram.createIx(name, ticker, ipfsUrl, coinPublicKey);
  
          const transaction = new Transaction();
  
          transaction.add(...createIxs);
  
          const buyIx = await sugarMoneyProgram.getTrade({
            tradeType: TradeTypeEnum.ExactIn,
            amountToTrade: new BN(solAmount * LAMPORTS_PER_SOL),
            tradeDirection: TradeDirectionEnum.Buy,
            mint: new PublicKey(mint),
          });
  
          transaction.add(buyIx);
  
          const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash({
            commitment: 'confirmed',
          });
  
          transaction.recentBlockhash = blockhash;
          transaction.feePayer = wallet.publicKey!;
  
          const userSignedTx = await wallet.signTransaction?.(transaction);
  
          const serializedTransaction = userSignedTx
            .serialize({
              requireAllSignatures: false,
              verifySignatures: false,
            })
            .toString('base64');
  
          await sugarMoneyApi.coin.postSignTransaction({
            serialisedTx: serializedTransaction,
            mint: coinPublicKey.toString(),
            blockhash,
            lastValidBlockHeight,
          });
        };
       * ```
       *
       * @param data - The data to sign the transaction
       * @returns The transaction signature
       */
    postSignTransaction: (data: SugarMoneyApiPostSignTransactionRequestType) => Promise<string>;
    get: ({ address }: SugarMoneyApiAddressRequestType) => Promise<SugarMoneyApiCoinResponseType>;
    getComments: ({ address, page, limit }: SugarMoneyApiAddressRequestType) => Promise<SugarMoneyApiCoinCommentResponseType[]>;
    comment: ({ address, comment }: SugarMoneyApiCommentRequestType) => Promise<SugarMoneyApiCommentResponseType>;
    getTrades: ({ address, page, limit }: SugarMoneyApiAddressRequestType) => Promise<SugarMoneyApiTradesResponseType[]>;
    getHolders: ({ address }: SugarMoneyApiAddressRequestType) => Promise<CoinHoldersResponseType>;
    getMint: () => Promise<string>;
    favorite: ({ address }: SugarMoneyApiAddressRequestType) => Promise<boolean>;
    unfavorite: ({ address }: SugarMoneyApiAddressRequestType) => Promise<boolean>;
    featured: () => Promise<SugarMoneyApiCoinResponseType>;
    /**
     * You can only delete a coin if it is yours and was not created on chain.
     */
    delete: ({ address }: {
        address: string;
    }) => Promise<boolean>;
    candlestick: ({ address, resolution, offset, limit, toTimestamp, isFirstDataRequest, }: {
        address: string;
        resolution: SugarMoneyApiAvailableCandlestickResolutionType;
        offset: number;
        limit: number;
        toTimestamp: number;
        isFirstDataRequest?: boolean;
    }) => Promise<SugarMoneyApiCandlestickDataResponseType>;
};

declare const AvailableCandlestickResolutions: readonly ["1m", "3m", "1h", "6h", "1d", "5d"];

type SugarMoneyApiCoinMetadataType = {
    name: string;
    symbol: string;
    description: string;
    twitter?: string;
    website?: string;
};
type SugarMoneyApiPostIpfsMetadataRequestType = {
    coinData: SugarMoneyApiCoinMetadataType;
    image: File;
};
type SugarMoneyApiPostIpfsMetadataResponseType = {
    ipfsUrl: string;
    ipfsImgUrl: string;
};
type SugarMoneyApiPostCoinRequestType = {
    image: File;
    metadata: SugarMoneyApiCoinMetadataType;
    migrationInPsol: boolean;
};
type SugarMoneyApiPostSignTransactionRequestType = {
    serialisedTx: string;
    mint: string;
    blockhash: string;
    lastValidBlockHeight: number;
};
type SugarMoneyApiPostSignTransactionResponseType = {
    signature: string;
};
declare enum SugarMoneyApiCoinMetadataOperationEnum {
    CoinCreationViaApi = "coin-creation-via-api",
    IpfsUrlForMetadata = "ipfs-url-for-metadata"
}
declare enum SugarMoneyApiCoinMetadataStatusEnum {
    Processing = "processing",
    Complete = "complete"
}
type SugarMoneyApiPostCoinMetadataResponse = {
    status: SugarMoneyApiCoinMetadataStatusEnum.Processing;
    receivedChunks: number[];
    totalChunks: number;
    fileId: string;
} | {
    ipfsUrlOriginalImage: string;
    ipfsUrlCompressedImage: string;
    ipfsUrlMetadata: string;
    fileId: string;
    status: SugarMoneyApiCoinMetadataStatusEnum.Complete;
} | string;
type SugarMoneyApiAddressRequestType = {
    address: string;
    page?: number;
    limit?: number;
};
type SugarMoneyApiCoinResponseType = {
    address: string;
    coinSymbol: string;
    coinName: string;
    coinSrc: string;
    coinCreationTime: number;
    coinMarketCap: number;
    username: string;
    holders: number;
    comments: number;
    xUrl: string | null;
    websiteUrl: string | null;
    featured: boolean;
    coinAmount: string;
    solPrice: string;
    solAmount: string;
    bondingCurve: string;
    creator: string;
    coinDescription: string | null;
    nsfw: boolean;
    metadataIpfsUrl?: string;
    bondingCurveComplete?: boolean;
    bondingCurveProgress: number;
    raydiumPoolAddress?: string | null;
    largestTradeSolAmount: string;
    largestTradeUsdAmount: string;
    signature: string | null;
    volumeSol: string;
    volumeUsd: string;
    migrationInPsol: boolean;
    migratedToRaydiumAt: string | null;
};
type SugarMoneyApiCoinCommentResponseType = {
    message: string | null;
    imageUri: string | null;
    createdAt: string;
    id: number;
    user: {
        username: string | null;
        image: string | null;
        publicKey: string;
    };
};
type SugarMoneyApiTradesResponseType = {
    publicKey: string;
    isBuy: boolean;
    time: number;
    price: string;
    amount: number;
    totalUsd: number;
    signature: string;
    solAmount: number;
};
type CoinHoldersResponseType = {
    data: {
        user: string;
        total: string;
    }[];
    updatedAt: number;
};
type SugarMoneyApiCoinMintResponseType = string;
type SugarMoneyApiCoinFavoriteResponseType = boolean;
type SugarMoneyApiCoinUnFavoriteResponseType = boolean;
type SugarMoneyApiAvailableCandlestickResolutionType = (typeof AvailableCandlestickResolutions)[number];
type SugarMoneyApiCandlestickDataResponseType = Array<{
    time: number;
    open: number;
    high: number;
    low: number;
    close: number;
    volume: number;
    trade_count: number;
}>;
type SugarMoneyApiCommentRequestType = {
    address: string;
    comment: string;
};
type SugarMoneyApiCommentResponseType = {
    id: number;
    mint: string;
    message: string;
    userId: string;
    createdAt: string;
};

type PaginationParams = {
    page?: number;
};
type SugarMoneyApiSearchCoinsRequestType = PaginationParams & {
    searchTerm: string;
    hideNsfw?: boolean;
};
type SearchCoinType = {
    image_uri: string;
    mint: string;
    name: string;
    solPrice: string;
    symbol: string;
    coinMarketCap: number;
};
type SugarMoneyApiSearchCoinsResponseType = {
    data: SearchCoinType[];
    nextPage: number | null;
    isMigratedToken: boolean;
};
type SugarMoneyApiCoinsResponseType = {
    coins: SugarMoneyApiCoinResponseType[];
    totalCount: number;
    page: number;
};
declare enum SearchParamsFilterEnum {
    Discover = "discover",
    New = "new",
    Favorites = "favorites"
}
type SugarMoneyApiCoinsRequestType = PaginationParams & {
    filter: SearchParamsFilterEnum;
    bondingCurveFrom?: number;
    bondingCurveTo?: number;
    marketCapFrom?: number;
    marketCapTo?: number;
    coinAgeFrom?: number;
    coinAgeTo?: number;
    solPriceUsd?: number;
    toShow?: string;
    doNotShow?: string;
    coinHoldersFrom?: number;
    coinHoldersTo?: number;
    hideNsfw: boolean;
};

declare const coinsModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    get: ({ page, filter, bondingCurveFrom, bondingCurveTo, marketCapFrom, marketCapTo, coinAgeFrom, coinAgeTo, solPriceUsd, toShow, doNotShow, coinHoldersFrom, coinHoldersTo, hideNsfw, }: SugarMoneyApiCoinsRequestType) => Promise<SugarMoneyApiCoinsResponseType>;
    search: ({ searchTerm, page, hideNsfw }: SugarMoneyApiSearchCoinsRequestType) => Promise<SugarMoneyApiSearchCoinsResponseType>;
};

type SugarMoneyApiRequestPayoutResponseType = {
    serialisedTransaction: string;
    blockhash: string;
    lastValidBlockHeight: number;
    nonce: number;
};
type SugarMoneyApiSubmitPayoutRequestType = {
    signed_tx: string;
    nonce: number;
    blockhash: string;
    lastValidBlockHeight: number;
};
type SugarMoneyApiSubmitPayoutResponseType = string;
type SugarMoneyApiPayoutProgressResponseType = {
    expiresAt: number;
    inProgress: boolean;
};
declare enum PayoutStatus {
    Pending = "PENDING",
    Paid = "PAID",
    Failed = "FAILED"
}
declare enum SugarMoneyTransactionStatusEnum {
    Processing = "processing",
    Success = "success",
    Failed = "failed",
    Dropped = "dropped",
    NotFound = "not_found"
}
type SugarMoneyTransactionStatusResponseType = {
    signature: string;
    status: SugarMoneyTransactionStatusEnum;
};

type SugarMoneyApiPointsHistoryType = {
    timestamp: number;
    points: number;
    tradingVolume: number;
};
type SugarMoneyApiPointsHistoryResponseType = SugarMoneyApiPointsHistoryType[];
type SugarMoneyApiUserHoldingsRequestType = {
    solPriceUsd: number;
};
type SugarMoneyApiUserHoldingType = {
    coin: SugarMoneyApiCoinResponseType;
    total: string;
    user: string;
    mint: string;
};
type SugarMoneyApiUserPreferencesType = {
    bribeAmount?: number | null;
    priorityFeeAmount?: number | null;
    maxFee?: number | null;
    quickBuy: boolean;
    quickBuy1: number;
    quickBuy2: number;
    quickBuy3: number;
    sellPrefersCoin: boolean;
    hideNsfw: boolean;
    maxSlippage?: number | null;
    selectedQuickBuy: number;
    autoSortingEnabled: boolean;
    username?: string | null;
    usernameUpdatedAt?: string | null;
    points: number;
    tickets: number;
    creatorPayout: number;
    pointsPumpFun: number;
    antiMevProtection: boolean;
    tradingSettingsAuto: boolean;
    sidebarOpen: boolean;
    revealedBonusPoints: boolean;
};
type SugarMoneyApiUserPreferencesUpdateType = Partial<SugarMoneyApiUserPreferencesType>;
type SugarMoneyApiUserTicketsResponseType = number;

declare const userModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    getCreatedCoins: () => Promise<SugarMoneyApiCoinResponseType[]>;
    getPointsHistory: () => Promise<SugarMoneyApiPointsHistoryResponseType>;
    getHoldings: ({ solPriceUsd }: SugarMoneyApiUserHoldingsRequestType) => Promise<SugarMoneyApiUserHoldingType[]>;
    getPreferences: () => Promise<SugarMoneyApiUserPreferencesType>;
    updatePreferences: (data: Partial<SugarMoneyApiUserPreferencesUpdateType>) => Promise<SugarMoneyApiUserPreferencesType>;
    getTickets: () => Promise<number>;
    getFavorites: () => Promise<SugarMoneyApiCoinResponseType[]>;
    creatorRewardsPayout: {
        request: () => Promise<SugarMoneyApiRequestPayoutResponseType>;
        submit: (data: SugarMoneyApiSubmitPayoutRequestType) => Promise<string>;
        inProgress: () => Promise<SugarMoneyApiPayoutProgressResponseType>;
    };
};

declare const priceModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    getSol: () => Promise<number>;
};

type SugarMoneyApiCurrentGameResponseType = {
    id: string;
    revealedPositions: number[];
    tickets: number;
} | null;
type SugarMoneyApiCreateGameRequestType = {
    tickets: number;
};
type SugarMoneyApiCreateGameResponseType = {
    gameId: string;
    updatedTickets: number;
    gameHashed: string;
};
type SugarMoneyApiUpdateGameRequestType = {
    gameId: string;
    index: number;
};
type SugarMoneyApiUpdateGameResponseType = {
    newPositions: number[];
    multiplier: number;
    isMatch: boolean;
    payoutAmount: string | null;
    state: number[] | null;
};
type SugarMoneyApiGameHistoryRequestType = {
    page?: number;
    pageSize?: number;
};
type SugarMoneyApiGameHistoryResponseType = {
    id: string;
    tickets: number;
    solAmount: string;
    createdAt: string;
    multiplier?: number | null;
    signature?: string | null;
    status?: PayoutStatus;
    updatedAt: string;
};

declare const gameModule: ({ makeApiRequest, checkTransactionStatus }: BuildModuleParamsType) => {
    current: () => Promise<{
        id: string;
        revealedPositions: number[];
        tickets: number;
    }>;
    create: ({ tickets }: SugarMoneyApiCreateGameRequestType) => Promise<SugarMoneyApiCreateGameResponseType>;
    update: ({ gameId, index }: SugarMoneyApiUpdateGameRequestType) => Promise<SugarMoneyApiUpdateGameResponseType>;
    history: ({ data }: {
        data: SugarMoneyApiGameHistoryRequestType;
    }) => Promise<SugarMoneyApiGameHistoryResponseType[]>;
    payout: {
        inProgress: () => Promise<SugarMoneyApiPayoutProgressResponseType>;
        request: () => Promise<SugarMoneyApiRequestPayoutResponseType>;
        submit: (data: SugarMoneyApiSubmitPayoutRequestType) => Promise<string>;
    };
};

type SugarMoneyApiGameType = {
    username: string;
    solReward: string;
    numberOfTickets: number;
    timestamp: number;
    gameId: string;
};
type SugarMoneyApiMostRecentGamesResponseType = SugarMoneyApiGameType[];

declare const gamesModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    getRecent: () => Promise<SugarMoneyApiMostRecentGamesResponseType>;
};

type SugarMoneyApiGetRanksResponseType = {
    ranks: Array<{
        rank: string;
        minPoints: string;
    }>;
    rate: number;
};

declare const ranksModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    getRanks: () => Promise<SugarMoneyApiGetRanksResponseType>;
};

declare const ticketsModule: ({ makeApiRequest, checkTransactionStatus, }: BuildModuleParamsType) => {
    maxAmount: () => Promise<number>;
    exchangeRate: () => Promise<number>;
    payout: {
        request: (data: {
            tickets: number;
        }) => Promise<SugarMoneyApiRequestPayoutResponseType>;
        submit: (data: SugarMoneyApiSubmitPayoutRequestType) => Promise<string>;
        inProgress: () => Promise<SugarMoneyApiPayoutProgressResponseType>;
    };
};

type SugarMoneyApiJitoPriorityFeesType = {
    landedTips25thPercentile: number;
    landedTips50thPercentile: number;
    landedTips75thPercentile: number;
    landedTips95thPercentile: number;
    landedTips99thPercentile: number;
    emaLandedTips50thPercentile: number;
};
type SugarMoneyApiQuickNodePriorityFeesType = {
    extreme: number;
    high: number;
    low: number;
    medium: number;
};
type SugarMoneyApiGetFeesResponseType = {
    jito: SugarMoneyApiJitoPriorityFeesType;
    regular: SugarMoneyApiQuickNodePriorityFeesType;
    coinCreationFee: number;
};

declare const feesModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    get: () => Promise<SugarMoneyApiGetFeesResponseType>;
};

type SugarMoneyWebSocketEventType = 'solana_price' | 'new_token' | 'token_create' | 'token_trade' | 'token_migrate' | 'token_complete' | 'token_featured' | 'token_comment';
interface SugarMoneyWebSocketSolanaPrice {
    price: number;
}
type SugarMoneyWebSocketToken = SugarMoneyApiCoinResponseType;
interface SugarMoneyWebSocketTokenTradeData {
    is_buy: boolean;
    total_usd: string;
    sol_amount: string;
    token_amount: string;
    timestamp: number;
    signature: string;
    user: string;
}
interface SugarMoneyWebSocketTokenWithTradeData extends SugarMoneyWebSocketToken {
    trade_data: SugarMoneyWebSocketTokenTradeData;
}
type SugarMoneyWebSocketTokenComment = SugarMoneyApiCoinCommentResponseType;
interface SugarMoneyWebSocketSolanaPriceEvent {
    type: 'solana_price';
    data: SugarMoneyWebSocketSolanaPrice;
}
interface SugarMoneyWebSocketNewTokenEvent {
    type: 'new_token';
    data: SugarMoneyWebSocketToken;
}
interface SugarMoneyWebSocketTokenCreateEvent {
    type: 'token_create';
    data: SugarMoneyWebSocketToken;
}
interface SugarMoneyWebSocketTokenTradeEvent {
    type: 'token_trade';
    data: SugarMoneyWebSocketTokenWithTradeData;
}
interface SugarMoneyWebSocketTokenMigratedEvent {
    type: 'token_migrate';
    data: SugarMoneyWebSocketToken;
}
interface SugarMoneyWebSocketTokenCompletedEvent {
    type: 'token_complete';
    data: SugarMoneyWebSocketToken;
}
interface SugarMoneyWebSocketTokenFeaturedEvent {
    type: 'token_featured';
    data: SugarMoneyWebSocketToken;
}
interface SugarMoneyWebSocketTokenCommentEvent {
    type: 'token_comment';
    data: SugarMoneyWebSocketTokenComment;
}
type SugarMoneyWebSocketEvent = SugarMoneyWebSocketSolanaPriceEvent | SugarMoneyWebSocketNewTokenEvent | SugarMoneyWebSocketTokenCreateEvent | SugarMoneyWebSocketTokenTradeEvent | SugarMoneyWebSocketTokenMigratedEvent | SugarMoneyWebSocketTokenCompletedEvent | SugarMoneyWebSocketTokenFeaturedEvent | SugarMoneyWebSocketTokenCommentEvent;
type SugarMoneyWebSocketConnectionState = 'connecting' | 'connected' | 'disconnected' | 'error';
type SugarMoneyWebSocketEventData = SugarMoneyWebSocketSolanaPrice | SugarMoneyWebSocketToken | SugarMoneyWebSocketTokenWithTradeData | SugarMoneyWebSocketTokenComment;
interface SugarMoneyWebSocketMessage<T = SugarMoneyWebSocketEventData> {
    type: string;
    data: T;
}
type SugarMoneyUniversalWebSocketHandler = (message: {
    type: SugarMoneyWebSocketEventType;
    data: SugarMoneyWebSocketEventData;
}) => void;
interface SugarMoneyWebSocketOptions {
    autoReconnect?: boolean;
    reconnectInterval?: number;
    maxReconnectAttempts?: number;
}
type SugarMoneyWebSocketEventHandler<T = any> = (data: T) => void;
type SugarMoneyWebSocketErrorHandler = (error: Error) => void;
type SugarMoneyWebSocketConnectionHandler = () => void;
interface SugarMoneyWebSocketEventHandlers {
    solana_price: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketSolanaPrice>;
    new_token: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketToken>;
    token_create: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketToken>;
    token_trade: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketTokenWithTradeData>;
    token_migrate: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketToken>;
    token_complete: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketToken>;
    token_featured: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketToken>;
    token_comment: SugarMoneyWebSocketEventHandler<SugarMoneyWebSocketTokenComment>;
}

declare class SugarMoneyWebSocketConnection {
    private ws;
    private environment;
    private options;
    private errorHandler;
    private connectionHandler;
    private disconnectionHandler;
    private universalHandlers;
    private reconnectAttempts;
    private reconnectTimeout;
    private state;
    constructor({ environment, options, }: {
        environment: SugarMoneyApiEnvironmentsEnum;
        options?: SugarMoneyWebSocketOptions;
    });
    /**
     * Connect to the WebSocket server
     */
    connect(): Promise<void>;
    /**
     * Disconnect from the WebSocket server
     */
    disconnect(): void;
    /**
     * Get the current connection state
     */
    getState(): SugarMoneyWebSocketConnectionState;
    /**
     * Check if the connection is established
     */
    isConnected(): boolean;
    /**
     * Subscribe to connection events
     */
    onConnection(handler: SugarMoneyWebSocketConnectionHandler): void;
    /**
     * Subscribe to disconnection events
     */
    onDisconnection(handler: SugarMoneyWebSocketConnectionHandler): void;
    /**
     * Subscribe to error events
     */
    onError(handler: SugarMoneyWebSocketErrorHandler): void;
    /**
     * Subscribe to ALL WebSocket messages with a universal handler
     */
    onAllMessages(handler: SugarMoneyUniversalWebSocketHandler): void;
    /**
     * Remove a universal message handler
     */
    offAllMessages(handler: SugarMoneyUniversalWebSocketHandler): void;
    /**
     * Handle incoming messages
     */
    private handleMessage;
    /**
     * Schedule a reconnection attempt
     */
    private scheduleReconnect;
}
declare const websocketModule: ({ environment, }: {
    environment: SugarMoneyApiEnvironmentsEnum;
}) => {
    /**
     * Get the current connection instance
     */
    getConnection: () => SugarMoneyWebSocketConnection;
    /**
     * Quick connect with default options
     */
    connect: (options?: SugarMoneyWebSocketOptions) => Promise<SugarMoneyWebSocketConnection>;
    /**
     * Disconnect the current connection
     */
    disconnect: () => void;
    /**
     * Subscribe to ALL WebSocket events with a single handler
     * Receives raw WebSocket messages directly without individual event parsing
     * @param handler - Function that receives the complete WebSocket message with proper typing
     */
    subscribeToAll: (handler: SugarMoneyUniversalWebSocketHandler) => void;
    /**
     * Unsubscribe from ALL WebSocket events
     * @param handler - The same handler function that was used to subscribe
     */
    unsubscribeFromAll: (handler: SugarMoneyUniversalWebSocketHandler) => void;
};

type SugarMoneyApiUserReferralsResponseType = {
    referralPendingPayout: number;
    tradingFees: number;
    ownReferralCode: string | null;
    ownReferralCodeEarnPercentage: number | null;
    referredUsers: {
        publicKey: string;
        referralTradingVolume: number;
        referralGeneratedAmount: number;
        createdAt: Date;
    }[];
    referredByPublicKey: string | null;
    totalReferredUsers: number;
};
type SugarMoneyApiCreateReferralCodeRequestType = {
    code: string;
};
type SugarMoneyApiCreateReferralCodeResponseType = {
    code: string;
    earnPercentage: number;
};
type SugarMoneyApiReferralCodeExistsRequestType = {
    code: string;
};
type SugarMoneyApiReferralCodeExistsResponseType = boolean;

declare const referralsModule: ({ makeApiRequest, checkTransactionStatus, }: BuildModuleParamsType) => {
    me: () => Promise<SugarMoneyApiUserReferralsResponseType>;
    createReferralCode: (data: SugarMoneyApiCreateReferralCodeRequestType) => Promise<SugarMoneyApiCreateReferralCodeResponseType>;
    codeExists: ({ code }: SugarMoneyApiReferralCodeExistsRequestType) => Promise<boolean>;
    payout: {
        inProgress: () => Promise<SugarMoneyApiPayoutProgressResponseType>;
        request: () => Promise<SugarMoneyApiRequestPayoutResponseType>;
        submit: (data: SugarMoneyApiSubmitPayoutRequestType) => Promise<string>;
    };
};

declare const transactionsModule: ({ makeApiRequest }: BuildModuleParamsType) => {
    checkStatus: ({ signature }: {
        signature: string;
    }) => Promise<SugarMoneyTransactionStatusResponseType>;
};

/**
 * The main class to interact with the SugarMoney API.
 *
 * @example
 * ```ts
 * const api = new SugarMoneyApi({ environment: ApiEnvironmentsEnum.Preprod });
 *
 * await api.login(args);
 * ```
 */
declare class SugarMoneyApi {
    private apiInstanceV1;
    private authApiInstance;
    private environment;
    private authToken;
    private sdkId;
    private makeApiRequestV1;
    coin: ReturnType<typeof coinModule>;
    coins: ReturnType<typeof coinsModule>;
    user: ReturnType<typeof userModule>;
    price: ReturnType<typeof priceModule>;
    game: ReturnType<typeof gameModule>;
    games: ReturnType<typeof gamesModule>;
    ranks: ReturnType<typeof ranksModule>;
    tickets: ReturnType<typeof ticketsModule>;
    fees: ReturnType<typeof feesModule>;
    referrals: ReturnType<typeof referralsModule>;
    websocket: ReturnType<typeof websocketModule>;
    transactions: ReturnType<typeof transactionsModule>;
    constructor({ environment, authToken, sdkId, }: {
        environment?: SugarMoneyApiEnvironmentsEnum;
        authToken?: string;
        sdkId?: string;
    });
    /**
     * Login to the API - the token lasts 30 days.
     *
     * You do not need to pass the token to other methods, the SDK will handle it.
     * Just make sure to call this and that it goes through successfuly.
     *
     * @param publicKey - The public wallet public key
     * @param signMessageFn - The function to sign a message to prove you own the wallet
     * @returns The auth token
     */
    login({ publicKey, signMessageFn, }: {
        publicKey: PublicKey;
        signMessageFn: SugarMoneyLoginSignMessageType;
    }): Promise<string>;
}

type ApiResponse<T> = {
    success: boolean;
    message: string;
    data: T;
};

type SugarMoneyApiSolPriceResponseType = number;

type SugarMoneyApiTicketsMaxAmountResponseType = number;
type SugarMoneyApiTicketsExchangeRateResponseType = number;

declare function generateSdkId(): string;

export { type ApiResponse, ApiUrls, type CoinHoldersResponseType, type PaginationParams, PayoutStatus, type SearchCoinType, SearchParamsFilterEnum, SugarMoneyApi, type SugarMoneyApiAddressRequestType, type SugarMoneyApiAvailableCandlestickResolutionType, type SugarMoneyApiCandlestickDataResponseType, type SugarMoneyApiCoinCommentResponseType, type SugarMoneyApiCoinFavoriteResponseType, SugarMoneyApiCoinMetadataOperationEnum, SugarMoneyApiCoinMetadataStatusEnum, type SugarMoneyApiCoinMetadataType, type SugarMoneyApiCoinMintResponseType, type SugarMoneyApiCoinResponseType, type SugarMoneyApiCoinUnFavoriteResponseType, type SugarMoneyApiCoinsRequestType, type SugarMoneyApiCoinsResponseType, type SugarMoneyApiCommentRequestType, type SugarMoneyApiCommentResponseType, type SugarMoneyApiCreateGameRequestType, type SugarMoneyApiCreateGameResponseType, type SugarMoneyApiCreateReferralCodeRequestType, type SugarMoneyApiCreateReferralCodeResponseType, type SugarMoneyApiCurrentGameResponseType, SugarMoneyApiEnvironmentsEnum, type SugarMoneyApiGameHistoryRequestType, type SugarMoneyApiGameHistoryResponseType, type SugarMoneyApiGameType, type SugarMoneyApiGetFeesResponseType, type SugarMoneyApiGetRanksResponseType, type SugarMoneyApiJitoPriorityFeesType, type SugarMoneyApiMostRecentGamesResponseType, type SugarMoneyApiPayoutProgressResponseType, type SugarMoneyApiPointsHistoryResponseType, type SugarMoneyApiPointsHistoryType, type SugarMoneyApiPostCoinMetadataResponse, type SugarMoneyApiPostCoinRequestType, type SugarMoneyApiPostIpfsMetadataRequestType, type SugarMoneyApiPostIpfsMetadataResponseType, type SugarMoneyApiPostSignTransactionRequestType, type SugarMoneyApiPostSignTransactionResponseType, type SugarMoneyApiQuickNodePriorityFeesType, type SugarMoneyApiReferralCodeExistsRequestType, type SugarMoneyApiReferralCodeExistsResponseType, type SugarMoneyApiRequestPayoutResponseType, type SugarMoneyApiSearchCoinsRequestType, type SugarMoneyApiSearchCoinsResponseType, type SugarMoneyApiSolPriceResponseType, type SugarMoneyApiSubmitPayoutRequestType, type SugarMoneyApiSubmitPayoutResponseType, type SugarMoneyApiTicketsExchangeRateResponseType, type SugarMoneyApiTicketsMaxAmountResponseType, type SugarMoneyApiTradesResponseType, type SugarMoneyApiUpdateGameRequestType, type SugarMoneyApiUpdateGameResponseType, type SugarMoneyApiUserHoldingType, type SugarMoneyApiUserHoldingsRequestType, type SugarMoneyApiUserPreferencesType, type SugarMoneyApiUserPreferencesUpdateType, type SugarMoneyApiUserReferralsResponseType, type SugarMoneyApiUserTicketsResponseType, type SugarMoneyLoginOptions, type SugarMoneyLoginResponseType, type SugarMoneyLoginSignMessageType, SugarMoneyTransactionStatusEnum, type SugarMoneyTransactionStatusResponseType, type SugarMoneyUniversalWebSocketHandler, type SugarMoneyWebSocketConnectionHandler, type SugarMoneyWebSocketConnectionState, type SugarMoneyWebSocketErrorHandler, type SugarMoneyWebSocketEvent, type SugarMoneyWebSocketEventData, type SugarMoneyWebSocketEventHandler, type SugarMoneyWebSocketEventHandlers, type SugarMoneyWebSocketEventType, type SugarMoneyWebSocketMessage, type SugarMoneyWebSocketNewTokenEvent, type SugarMoneyWebSocketOptions, type SugarMoneyWebSocketSolanaPrice, type SugarMoneyWebSocketSolanaPriceEvent, type SugarMoneyWebSocketToken, type SugarMoneyWebSocketTokenComment, type SugarMoneyWebSocketTokenCommentEvent, type SugarMoneyWebSocketTokenCompletedEvent, type SugarMoneyWebSocketTokenCreateEvent, type SugarMoneyWebSocketTokenFeaturedEvent, type SugarMoneyWebSocketTokenMigratedEvent, type SugarMoneyWebSocketTokenTradeData, type SugarMoneyWebSocketTokenTradeEvent, type SugarMoneyWebSocketTokenWithTradeData, VersionEnum, WebsocketUrls, generateSdkId };