type OnlyFansRules = {
    static_param: string;
    format: string;
    checksum_indexes: number[];
    checksum_constant: number;
    app_token: string;
    remove_headers: string[];
    error_code: number;
    message: string;
};
declare const getOnlyFansRules: () => Promise<OnlyFansRules>;

declare function getHash(rules: OnlyFansRules, settings: {
    time: number;
    auth_id: string;
    path: string;
}): Promise<{
    sign: string;
    time: number;
}>;

interface OnlyFansBalances {
    payoutAvailable: number;
    payoutPending: number;
    currency: "USD" | string;
    minPayoutSumm: number;
    maxPayoutSumm: number;
    withdrawalPeriodOptions: {
        code: string;
        name: string;
    }[];
}

type OnlyFansMe = {
    view: string;
    avatar: string;
    avatarThumbs: {
        c50: string;
        c144: string;
    };
    header: string;
    headerSize: {
        width: number;
        height: number;
    };
    headerThumbs: {
        w480: string;
        w760: string;
    };
    id: number;
    name: string;
    username: string;
    canLookStory: boolean;
    canCommentStory: boolean;
    hasNotViewedStory: boolean;
    isVerified: boolean;
    canPayInternal: boolean;
    canSendChatToAll: boolean;
    creditsMin: number;
    creditsMax: number;
    isPaywallRestriction: boolean;
    unprofitable: boolean;
    listsSort: string;
    listsSortOrder: string;
    canCreateLists: boolean;
    joinDate: string;
    isReferrerAllowed: boolean;
    about: string;
    rawAbout: string;
    website: null;
    wishlist: null;
    location: null;
    postsCount: number;
    archivedPostsCount: number;
    photosCount: number;
    videosCount: number;
    audiosCount: number;
    mediasCount: number;
    lastSeen: null;
    favoritesCount: number;
    favoritedCount: number;
    showPostsInFeed: boolean;
    canReceiveChatMessage: boolean;
    isPerformer: boolean;
    isRealPerformer: boolean;
    isSpotifyConnected: boolean;
    subscribersCount: number;
    hasPinnedPosts: boolean;
    hasLabels: boolean;
    canChat: boolean;
    canAddPhone: boolean;
    phoneLast4: null;
    phoneMask: null;
    hasNewTicketReplies: {
        open: boolean;
        solved: boolean;
        closed: boolean;
    };
    hasInternalPayments: boolean;
    isCreditsEnabled: boolean;
    creditBalance: number;
    isMakePayment: boolean;
    isAgeVerified: boolean;
    ageVerificationRequired: boolean;
    isOtpEnabled: boolean;
    email: string;
    isEmailChecked: boolean;
    isLegalApprovedAllowed: boolean;
    isTwitterConnected: boolean;
    twitterUsername: string;
    isAllowTweets: boolean;
    isPaymentCardConnected: boolean;
    referalUrl: string;
    isVisibleOnline: boolean;
    subscribesCount: number;
    canPinPost: boolean;
    hasNewAlerts: boolean;
    hasNewHints: boolean;
    hasNewChangedPriceSubscriptions: boolean;
    notificationsCount: number;
    hasSystemNotifications: boolean;
    chatMessagesCount: number;
    isWantComments: boolean;
    watermarkText: string;
    customWatermarkText: null;
    hasWatermarkPhoto: boolean;
    hasWatermarkVideo: boolean;
    canDelete: boolean;
    isTelegramConnected: boolean;
    advBlock: string[];
    hasPurchasedPosts: boolean;
    isEmailRequired: boolean;
    isPayoutLegalApproved: boolean;
    payoutLegalApproveState: string;
    payoutLegalApproveRejectReason: string;
    enabledImageEditorForChat: boolean;
    shouldReceiveLessNotifications: boolean;
    canCalling: boolean;
    paidFeed: boolean;
    canSendSms: boolean;
    canAddFriends: boolean;
    isRealCardConnected: boolean;
    countPriorityChat: number;
    hasScenario: boolean;
    wsAuthToken: string;
    canAddCard: boolean;
    isWalletAutorecharge: boolean;
    walletAutorechargeAmount: number;
    walletAutorechargeMin: number;
    walletFirstRebills: boolean;
    closeFriends: number;
    canAlternativeWalletTopUp: boolean;
    needIVApprove: boolean;
    ivStatus: string;
    ivFailReason: string;
    canCheckDocsOnAddCard: boolean;
    faceIdAvailable: boolean;
    ivCountry: string;
    ivForcedVerified: boolean;
    ivFlow: string;
    connectedOfAccounts: any[];
    hasPassword: boolean;
    canConnectOfAccount: boolean;
    pinnedPostsCount: number;
    maxPinnedPostsCount: number;
    isDeleteInitiated: boolean;
    forceFaceOtp: boolean;
};

type OnlyFansNotificationsRequest = {
    limit?: number;
    offset?: number;
    skip_users?: "all" | number;
    format?: "infinite" | string;
    type?: "subscribed" | "purchases" | "tip" | "commented" | string;
};
type OnlyFansNotificationsResponse = {
    list: OnlyFansNotification[];
    hasMore: boolean;
};
type OnlyFansNotification = {
    id: number;
    type: string;
    createdAt: string;
    isRead: boolean;
    text: string;
    replacePairs: {
        "{USER_LINK}"?: string;
        "{BASE_URL}": string;
        "{RECIPIENT_ID}": string;
        "{RECIPIENT_NAME}": string;
        "{RECIPIENT_LOGIN}": string;
        "{RECIPIENT_URL}": string;
        "{RECIPIENT_EMAIL}": string;
        "{RELATED_USER_ID}": string;
        "{RELATED_USER_NAME}": string;
        "{RELATED_USER_LOGIN}": string;
        "{RELATED_USER_URL}": string;
        "{RELATED_USER_AVATAR}": string;
        "{RELATED_USER_HAS_AVATAR}": number;
        "{RELATED_USER_SHORT_NAME}": string;
        "{SUBSCRIBER_LINK}"?: string;
        "{PRICE}"?: string;
    };
    subType: string;
    canGoToProfile: boolean;
    newPrice?: null;
    user: {
        id: number;
        _view: string;
    };
};

type OnlyFansObjectUser = {
    id: number;
    _view: string;
};
type OnlyFansActionResponse = {
    success: boolean;
};

type OnlyFansMediaResponse = {
    list: OnlyFansMedia[];
    hasMore: boolean;
};
type OnlyFansMedia = {
    id: number;
    type: "photo" | "video";
    convertedToVideo: boolean;
    canView: boolean;
    hasError: boolean;
    createdAt: string;
    counters?: {
        likesCount: number;
        tipsSumm: number;
    };
    info: {
        source: OnlyFansSource;
        preview?: {
            width: number;
            height: number;
            size: number;
        };
    };
    source: OnlyFansSource;
    squarePreview: string | null;
    full: string | null;
    preview: string | null;
    thumb: string | null;
    files?: {
        preview: {
            url: string;
        };
    };
    videoSources?: {
        "720": null | string;
        "240": null | string;
    };
    listStates?: ListState[];
    postId?: number;
    posts?: {
        id: number;
        createdAt: string;
    }[];
};
type ListState = {
    id: number;
    type: "messages" | "stories" | "posts" | "streams" | "custom";
    name: string;
    hasMedia: boolean;
    canAddMedia: boolean;
};
type OnlyFansSource = {
    source: string | null;
    width: number;
    height: number;
    size: number;
    duration: number;
};

type OnlyFansPostsRequest = {
    limit?: number;
    offset?: number;
    order?: "publish_date_desc" | "publish_date_asc" | string;
    pinned?: "0" | "1" | string;
    beforePublishTime?: string;
    counters?: number;
    format?: "infinite" | string;
    skip_users?: "all" | string;
};
type OnlyFansPostsResponse = {
    list: OnlyFansPost[];
    hasMore: boolean;
    counters?: {
        audiosCount: number;
        photosCount: number;
        videosCount: number;
        mediasCount: number;
        postsCount: number;
        archivedPostsCount: number;
    };
};
type OnlyFansFeedPostsResponse = {
    list: OnlyFansPost[];
    hasMore: boolean;
    headMarker: string;
    tailMarker: string;
};
type OnlyFansPost = {
    responseType: string;
    id: number;
    postedAt: string;
    postedAtPrecise: string;
    expiredAt: string | null;
    author: OnlyFansObjectUser;
    text: string;
    rawText: string;
    lockedText: boolean;
    isFavorite: boolean;
    canReport: boolean;
    canDelete: boolean;
    canComment: boolean;
    canEdit: boolean;
    isPinned: boolean;
    favoritesCount: number;
    mediaCount: number;
    isMediaReady: boolean;
    voting?: OnlyFansVoting | any;
    votingType?: number;
    canVote?: boolean;
    isOpened: boolean;
    canToggleFavorite: boolean;
    streamId: null;
    price: null | number;
    hasVoting: boolean;
    isAddedToBookmarks: boolean;
    isArchived: boolean;
    isDeleted: boolean;
    hasUrl: boolean;
    cantCommentReason?: string;
    commentsCount: number;
    mentionedUsers: OnlyFansObjectUser[];
    linkedUsers: OnlyFansObjectUser[];
    linkedPosts: OnlyFansPost[];
    media: OnlyFansMedia[];
    canViewMedia: boolean;
    preview: number[];
    tipsAmount?: string;
    tipsAmountRaw?: number;
    fundRaising?: any;
};
type OnlyFansVoting = {
    finishedAt: string;
    options: {
        id: number;
        name: string;
        count: null;
        isVoted: boolean;
    }[];
    total: number;
};

type OnlyFansPromotion = {
    id: number;
    message: string;
    rawMessage: string;
    hasRelatedPromo: boolean;
    price: number;
    type: string;
    canClaim: boolean;
    claimsCount: number;
    subscribeCounts: number | null;
    subscribeDays: number | null;
    createdAt: string | null;
    finishedAt: string | null;
};

type OnlyFansSendMessageRequest = {
    lockedText: boolean;
    mediaFiles: any[];
    previews: any[];
    price: number;
    text: string;
};
interface OnlyFansSendMessageResponse {
    responseType: string;
    text: string;
    lockedText: boolean;
    isFree: boolean;
    price: number;
    isMediaReady: boolean;
    mediaCount: number;
    media: any[];
    previews: any[];
    isTip: boolean;
    isReportedByMe: boolean;
    fromUser: OnlyFansObjectUser;
    isFromQueue: boolean;
    id: number;
    isOpened: boolean;
    isNew: boolean;
    createdAt: Date;
    changedAt: Date;
    cancelSeconds: number;
    isLiked: boolean;
    canPurchase: boolean;
    canPurchaseReason: string;
    canReport: boolean;
}

type OnlyFansSettings = {
    isDeleteInitiated: boolean;
    lastSubscriptionExpiredAt: null;
    streamingObsKey: null;
    streamingObsServer: null;
    streamingMuxKey: null;
    streamingMuxServer: null;
    streamingMuxKeyExpiredAt: null;
    activityHubAllowed: boolean;
    activityHubTokens: any[];
    confirmEmailSentAt: string;
    hideAfterMassMessages: boolean;
    changelogUpdates: number;
    showFullTextInEmailNotify: boolean;
    isPrivate: boolean;
    blockedCountries: any[];
    blockedStates: any[];
    blockedIps: any[];
    showPostsTips: boolean;
    recommenderReward: null;
    showFriendsToSubscribers: boolean;
    showSubscribesOffers: boolean;
    disableSubscribesOffers: boolean;
    isEmailNotificationsEnabled: boolean;
    canAcceptMessageOnlyFromFriends: boolean;
    isAutoFollowBack: boolean;
    changeEmailStep: null;
    newEmail: null;
    lifeTimeEmailCode: null;
    coStreamingRequestFrom: string;
    hasPaidPosts: boolean;
    isCoStreamingAllowed: boolean;
    isMonthlyNewsletters: boolean;
    strongOtp: boolean;
    phoneOtp: boolean;
    appOtp: boolean;
    isOtpAppConnected: boolean;
    isOldLoginRedirect: boolean;
    faceOtp: boolean;
    canSocialsConnect: boolean;
    socialsConnects: any[];
    webauthnConnectedCount: number;
    importantSubscriptionNotifications: boolean;
    isOpenseaConnected: boolean;
};

type OnlyFansSubscriberRequest = {
    limit?: number;
    offset?: number;
    type?: "all" | "active" | "expired" | "attention" | string;
    sort?: "asc" | "desc";
    field?: "expire_date" | "last_activity" | string;
};
type OnlyFansSubscriber = {
    view: string;
    avatar: null | string;
    avatarThumbs: null | {
        c50: string;
        c144: string;
    };
    header: null | string;
    headerSize: null | {
        width: number;
        height: number;
    };
    headerThumbs: null | {
        w480: string;
        w760: string;
    };
    id: number;
    name: string;
    username: string;
    canLookStory: boolean;
    canCommentStory: boolean;
    hasNotViewedStory: boolean;
    isVerified: boolean;
    canPayInternal: boolean;
    hasScheduledStream: boolean;
    hasStream: boolean;
    hasStories: boolean;
    tipsEnabled: boolean;
    tipsTextEnabled: boolean;
    tipsMin: number;
    tipsMinInternal: number;
    tipsMax: number;
    canEarn: boolean;
    canAddSubscriber: boolean;
    subscribePrice: number;
    subscriptionBundles?: {
        id: number;
        discount: number;
        duration: number;
        price: number;
        canBuy: boolean;
    }[];
    isPaywallRestriction: boolean;
    unprofitable?: boolean;
    listsStates: {
        id: number;
        type: string;
        name: string;
        hasUser: boolean;
        canAddUser: boolean;
    }[];
    isMuted: boolean;
    isRestricted: boolean;
    canRestrict: boolean;
    subscribedBy: boolean | null;
    subscribedByExpire: boolean | null;
    subscribedByExpireDate: string;
    subscribedByAutoprolong: boolean | null;
    subscribedIsExpiredNow: boolean | null;
    currentSubscribePrice: number | null;
    subscribedOn: null | boolean;
    subscribedOnExpiredNow: null | boolean;
    subscribedOnDuration: null | string;
    isSuspended?: boolean | null;
    canReport: boolean;
    canReceiveChatMessage: boolean;
    hideChat: boolean;
    lastSeen: string | null;
    isPerformer: boolean;
    isRealPerformer: boolean;
    promotions?: OnlyFansPromotion[];
    subscribedByData: {
        price: number;
        newPrice: number;
        regularPrice: number;
        subscribePrice: number;
        discountPercent: number;
        discountPeriod: number;
        subscribeAt: string | null;
        expiredAt: string | null;
        renewedAt: string | null;
        discountFinishedAt: string | null;
        discountStartedAt: string | null;
        status: string | null;
        isMuted: boolean;
        unsubscribeReason: string;
        duration: string;
        showPostsInFeed: boolean;
        newPostsAfterExpireCount?: number;
        lastPostDate?: string | null;
        subscribes: {
            id: number;
            userId: number;
            subscriberId: number;
            date: string;
            duration: number;
            startDate: string;
            expireDate: string;
            cancelDate: null;
            price: number;
            regularPrice: number;
            discount: number;
            earningId: number;
            action: string;
            type: string;
            offerStart: string | null;
            offerEnd: string | null;
            isCurrent: boolean;
        }[];
    };
    subscribedOnData: any;
    canTrialSend: boolean;
    isBlocked: boolean;
    displayName?: any;
    notice?: any;
};

type OnlyFansTransactionUser = {
    view: string;
    id: number;
    name: string;
    username: string;
    avatar: null | string;
    avatarThumbs: null | {
        c50: string;
        c144: string;
    };
};
type OnlyFansTransaction = {
    amount: number;
    createdAt: string;
    currency: string;
    status: string;
    description: string;
    card?: {
        last4: string;
        brand: "Visa" | "Mastercard" | string;
    };
    id: string;
    vatName?: string;
    vatPercentage?: number;
    vatAmount?: number;
    net?: number;
    fee?: number;
    user: OnlyFansTransactionUser;
    source?: string;
};
type OnlyFansTransactionResponse = {
    list: OnlyFansTransaction[];
    hasMore: boolean;
    marker: number;
    nextMarker: number;
};

type OnlyFansVaultMediaHiddenRequest = {
    mediaIds: number[];
};
type OnlyFansVaultMediaHiddenResponse = {
    success: boolean;
};
type OnlyFansVaultMediaRequest = {
    limit: number;
    offset: number;
    field: "recent" | "most-liked" | "highest-tips";
    sort: "desc" | "asc";
    type?: "photo" | string;
    list?: number;
};
declare const OnlyFansVaultMediaDefaultRequest: {
    limit: number;
    offset: number;
    field: string;
    sort: string;
};
type OnlyFansVaultMediaResponse = {
    list: OnlyFansMedia[];
    hasMore: boolean;
};

type OnlyFansHeaders = {
    cookie: string;
    "user-agent": string;
    "x-bc": string;
    [key: string]: string;
};
declare const SUBSCRIBES_DEFAULT: OnlyFansSubscriberRequest;
declare const POSTS_DEFAULT: OnlyFansPostsRequest;

type OnlyFansChatReqest = {
    limit?: number;
    offset?: number;
    order?: "recent" | "unread_tips" | "who_tipped" | string;
    list_id?: number;
    skip_users?: "all" | string;
    filters?: string;
    [key: string]: any;
};
type OnlyFansChatResponse = {
    list: OnlyFansChat[];
    hasMore: boolean;
    nextOffset: number;
};
type OnlyFansChat = {
    withUser: OnlyFansObjectUser;
    canGoToProfile: boolean;
    canSendMessage: boolean;
    canNotSendReason: boolean | string;
    unreadMessagesCount: number;
    hasUnreadTips: boolean;
    isMutedNotifications: boolean;
    lastMessage: OnlyFansMessage;
    lastReadMessageId: number;
    hasPurchasedFeed: boolean;
};
type OnlyFansMessage = {
    responseType: "message";
    text: string;
    lockedText: boolean;
    isFree: boolean;
    price: number;
    isMediaReady: boolean;
    mediaCount: number;
    media: Media[];
    previews: number[];
    isTip: boolean;
    isReportedByMe: boolean;
    fromUser: OnlyFansObjectUser;
    isFromQueue: boolean;
    queueId?: number;
    canUnsendQueue?: boolean;
    unsendSecondsQueue?: number;
    id: number;
    isOpened: boolean;
    isNew: boolean;
    createdAt: string;
    changedAt: string;
    cancelSeconds: number;
    isLiked: boolean;
    canPurchase: boolean;
    canPurchaseReason: string;
    canReport: boolean;
};
type Media = {
    id: number;
    canView: boolean;
    type: "audio" | "gif" | "photo" | "video";
    src: null | string;
    preview: null | string;
    thumb: null | string;
    locked: null;
    duration: number;
    hasError: boolean;
    videoSources: {
        [key: string]: null | string;
    };
    source: Source;
    info: Info;
    squarePreview?: null | string;
    video?: {
        mp4: string;
    };
};
type Info = {
    source: Preview;
    preview?: Preview;
};
type Preview = {
    width: number;
    height: number;
    size: number;
};
type Source = {
    source: null | string;
};

type OnlyFansInit = {
    pwaPublicKey: string;
    postMediaConfig: {
        types: Array<string>;
        ext: {
            gif: string;
            photo: string;
            banking: string;
            video: string;
            stream: string;
            audio: string;
            vat_doc: string;
        };
        count: {
            gif: number;
            photo: number;
            video: number;
            stream: number;
            audio: number;
        };
        params: {
            photo: {
                max_width: number;
                max_height: number;
                min_width: number;
                min_height: number;
            };
            banking: {
                max_file_size: number;
                min_file_size: number;
                max_width: number;
                max_height: number;
                min_width: number;
                min_height: number;
                min_dpi: number;
                min_format_size: {
                    x: number;
                    y: number;
                };
            };
            vat_doc: {
                max_file_size: number;
                max_width: number;
                max_height: number;
                min_width: number;
                min_height: number;
                min_dpi: number;
            };
        };
        prefix: string;
        thumbs_prefix: string;
        geo_server_host: string;
        geo_converter: {
            hosts: Array<string>;
            proto: string;
            path: string;
            args: {
                preset: string;
                isDelay: boolean;
                needThumbs: boolean;
            };
            types: Array<string>;
        };
        extensions: {
            gif: Array<string>;
            photo: Array<string>;
            banking: Array<string>;
            video: Array<string>;
            stream: Array<string>;
            audio: Array<string>;
            vat_doc: Array<string>;
        };
    };
    personalConfig: {
        prefix: string;
        avatar: {
            minWidth: number;
            minHeight: number;
        };
        header: {
            minWidth: number;
            minHeight: number;
        };
        max_pinned_posts_count: number;
    };
    streamingServer: string;
    settings: {
        isImageWatermarkNeeded: boolean;
        userLoginPrefix: string;
        subscribeMinPrice: number;
        subscribeMaxPrice: number;
    };
    languages: {
        en: string;
        zh: string;
        tw: string;
        pt: string;
        es: string;
        ja: string;
        ko: string;
        hi: string;
        fr: string;
        de: string;
        it: string;
        ro: string;
        ar: string;
        uk: string;
        ru: string;
    };
    thumbs: {
        "https://media.onlyfans.com/files/": string;
        "https://cdn.onlyfans.com/files/": string;
    };
    paymentGatesEnabledForCardAdd: Array<string>;
    cardsApiUrl: string;
    cards: {
        securionpay: {
            publicKeys: Array<{
                publicKey: string;
                first?: Array<any>;
                users?: Array<{
                    comparison: string;
                    id: number;
                }>;
            }>;
        };
        securionpayWl: {
            publicKey: string;
        };
        inovio: {
            proxyHost: any;
        };
    };
    cardholderStopwords: Array<string>;
    allowedMessages: Array<string>;
    tipsMin: number;
    tipsMinInternal: number;
    isScanCardEnabled: boolean;
    isPostsViewsEnabled: boolean;
    isProfilesViewsEnabled: boolean;
    isProfilesVisitsEnabled: boolean;
    isClicksStatsEnabled: boolean;
    upload: {
        uploadUrl: string;
        videoUploadHost: string;
        videoUploadUrl: string;
        geoUploadHost: string;
        geoUploadUrl: string;
        geoUploadArgs: {
            preset: string;
            isDelay: boolean;
            needThumbs: boolean;
            additional: {
                user: string;
            };
        };
        geoUploadTypes: Array<string>;
        geoUploadFallback: Array<{
            host: string;
            url: string;
        }>;
        geoUploadHosts: Array<{
            host: string;
            url: string;
        }>;
        s3: {
            bucketName: string;
            bucketRegion: string;
            useAccelerateEndpoint: boolean;
            accessKeyId: string;
            secretAccessKey: string;
            uploadUrl: string;
            uploadPath: string;
            secureUploadPath: string;
        };
    };
    isAuth: boolean;
    obsStreamingServer: any;
    cardVerification: {
        maxAmount: number;
        minAmount: number;
    };
    usersLinksMaxLimit: number;
    socialButtonsMaxLimit: number;
    socialMediaProviders: Array<{
        name: string;
        memberBaseUrl?: string;
    }>;
    ip: string;
    csrf: string;
    textsRev: string;
    hCaptchaSiteKey: string;
    hCaptchaPassiveSiteKey: string;
    recaptchaV2Public: any;
    recaptchaV3Public: any;
    recaptchaEPublic: string;
    recaptchaECPublic: string;
};

type OnlyFansTrialsRequest = {
    limit?: number;
    offset?: number;
    pagination?: number;
};
type OnlyFansTrialsResponse = {
    list: OnlyFansTrial[];
    hasMore: boolean;
};
type OnlyFansTrial = {
    id: number;
    trialLinkName: null | string;
    url: string;
    subscribeDays: number;
    subscribeCounts: number;
    claimCounts: number;
    expiredAt: null | string;
    createdAt: string;
    isFinished: boolean;
};
type OnlyFansAddTrialRequest = {
    /** The number of days the trial will last. 0 for no expiry */
    expireDays: number;
    subscribeCounts: number;
    subscribeDays: number;
    trialLinkName: string;
};

declare class OnlyFansService {
    headers: OnlyFansHeaders;
    rules: OnlyFansRules | undefined;
    debug: boolean;
    constructor(headers: OnlyFansHeaders, rules?: OnlyFansRules, debug?: boolean);
    getX: (path: string, params?: {}, method?: string) => Promise<any>;
    getMySubscriptions: (req?: OnlyFansSubscriberRequest) => Promise<OnlyFansSubscriber[]>;
    getMySubscribers: (req?: OnlyFansSubscriberRequest) => Promise<OnlyFansSubscriber[]>;
    getBalances: () => Promise<OnlyFansBalances>;
    getChats: (req?: OnlyFansChatReqest) => Promise<OnlyFansChatResponse>;
    getAllChats: () => Promise<OnlyFansChat[]>;
    getFeedPosts: (req: OnlyFansPostsRequest) => Promise<OnlyFansFeedPostsResponse>;
    sendMessage: (payload: OnlyFansSendMessageRequest) => Promise<OnlyFansSendMessageResponse>;
    getPosts: (id: number, req: OnlyFansPostsRequest) => Promise<OnlyFansPostsResponse>;
    getAllPosts: (id: number, maxPages?: number) => Promise<OnlyFansPost[]>;
    getMyProfile: () => Promise<OnlyFansMe>;
    getInit: () => Promise<OnlyFansInit>;
    deleteVaultMedia: (req: OnlyFansVaultMediaHiddenRequest) => Promise<OnlyFansVaultMediaHiddenResponse>;
    getVaultList: (req: OnlyFansVaultMediaHiddenRequest) => Promise<OnlyFansVaultMediaHiddenResponse>;
    getVaultMedia: (req: OnlyFansVaultMediaRequest) => Promise<OnlyFansVaultMediaResponse>;
    getAllVaultMedia: (maxPages?: number) => Promise<OnlyFansMedia[]>;
    getNotifications: () => Promise<OnlyFansNotificationsResponse>;
    getTrials: (req: OnlyFansTrialsRequest) => Promise<OnlyFansTrialsResponse>;
    addTrial: (req: OnlyFansAddTrialRequest) => Promise<OnlyFansTrial>;
    deleteTrial: (trialId: number) => Promise<OnlyFansActionResponse>;
    getTransaction: (startDate: string, marker: number) => Promise<OnlyFansTransactionUser>;
}

type Cookies = {
    [key: string]: string;
};
type Storage = {
    [key: string]: string;
};
type Headers = {
    "user-agent": string;
    [key: string]: string;
};
declare function object2cookie(obj: Cookies): string;
declare const createHeaders: (cookies: Cookies, storage: Storage, headers: Headers) => OnlyFansHeaders;

export { ListState, OnlyFansBalances, OnlyFansFeedPostsResponse, OnlyFansHeaders, OnlyFansMe, OnlyFansMedia, OnlyFansMediaResponse, OnlyFansNotification, OnlyFansNotificationsRequest, OnlyFansNotificationsResponse, OnlyFansPost, OnlyFansPostsRequest, OnlyFansPostsResponse, OnlyFansPromotion, OnlyFansRules, OnlyFansSendMessageRequest, OnlyFansSendMessageResponse, OnlyFansService, OnlyFansSettings, OnlyFansSource, OnlyFansSubscriber, OnlyFansSubscriberRequest, OnlyFansTransaction, OnlyFansTransactionResponse, OnlyFansTransactionUser, OnlyFansVaultMediaDefaultRequest, OnlyFansVaultMediaHiddenRequest, OnlyFansVaultMediaHiddenResponse, OnlyFansVaultMediaRequest, OnlyFansVaultMediaResponse, OnlyFansVoting, POSTS_DEFAULT, SUBSCRIBES_DEFAULT, createHeaders, getHash, getOnlyFansRules, object2cookie };