onlyfans 0.1.0

data/rbi/onlyfans/resources/chats/messages.rbi

@@ -0,0 +1,250 @@
+# typed: strong
+
+module Onlyfans
+  module Resources
+    class Chats
+      class Messages
+        # Get a single chat message by its ID. Returns a 404 if the message does not exist
+        # in the chat.
+        sig do
+          params(
+            message_id: String,
+            account: String,
+            chat_id: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageRetrieveResponse)
+        end
+        def retrieve(
+          # The ID of the message to retrieve
+          message_id,
+          # The Account ID
+          account:,
+          # The ID of the chat (usually a fan's OnlyFans User ID)
+          chat_id:,
+          request_options: {}
+        )
+        end
+
+        # Get messages from a specific chat.
+        sig do
+          params(
+            chat_id: String,
+            account: String,
+            filter: Onlyfans::Chats::MessageListParams::Filter::OrSymbol,
+            first_id: T.nilable(String),
+            last_id: T.nilable(String),
+            limit: String,
+            order: String,
+            skip_users: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageListResponse)
+        end
+        def list(
+          # Path param: The ID of the chat (usually a fan's OnlyFans User ID)
+          chat_id,
+          # Path param: The Account ID
+          account:,
+          # Query param: Filter by certain messages. Currently, only pins are filterable.
+          filter: nil,
+          # Query param: Use for pagination when `order=desc` (newest to oldest). Include
+          # this message ID as the first message in the results. Used to retrieve messages
+          # from e.g. the Search Chat Messages endpoint IDs.
+          first_id: nil,
+          # Query param: Use for pagination when `order=asc` (oldest to newest). Include
+          # this message ID as the first message in the results. WARNING! The response list
+          # of messages will also be inverted (oldest messages will be first, opposite to
+          # default where `order=desc`).
+          last_id: nil,
+          # Query param: The number of messages to return (default = 10, max = 100)
+          limit: nil,
+          # Query param: Sort order for messages (desc or asc)
+          order: nil,
+          # Query param: Whether to skip user details (all or none)
+          skip_users: nil,
+          request_options: {}
+        )
+        end
+
+        # Delete a message from a chat. Please note that ONLY messages sent less than 24
+        # hours ago can be deleted.
+        sig do
+          params(
+            message_id: String,
+            account: String,
+            chat_id: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageDeleteResponse)
+        end
+        def delete(
+          # The ID of the message to retrieve
+          message_id,
+          # The Account ID
+          account:,
+          # The ID of the chat (usually a fan's OnlyFans User ID)
+          chat_id:,
+          request_options: {}
+        )
+        end
+
+        # Like a chat message.
+        sig do
+          params(
+            message_id: String,
+            account: String,
+            chat_id: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageLikeResponse)
+        end
+        def like(
+          # The ID of the message to like
+          message_id,
+          # The Account ID
+          account:,
+          # The ID of the chat, usually a fan's OnlyFans User ID
+          chat_id:,
+          request_options: {}
+        )
+        end
+
+        # Pin a message from a chat.
+        sig do
+          params(
+            message_id: String,
+            account: String,
+            chat_id: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessagePinResponse)
+        end
+        def pin(
+          # The ID of the message to pin
+          message_id,
+          # The Account ID
+          account:,
+          # The ID of the chat, usually a fan's OnlyFans User ID
+          chat_id:,
+          request_options: {}
+        )
+        end
+
+        # Search messages in a specific chat. Returns a list of message IDs matching the
+        # search query.
+        sig do
+          params(
+            chat_id: String,
+            account: String,
+            query: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageSearchResponse)
+        end
+        def search(
+          # Path param: The ID of the chat (usually a fan's OnlyFans User ID)
+          chat_id,
+          # Path param: The Account ID
+          account:,
+          # Query param: The query search in messages.
+          query:,
+          request_options: {}
+        )
+        end
+
+        # Send a new message to a chat.
+        sig do
+          params(
+            chat_id: String,
+            account: String,
+            giphy_id: String,
+            locked_text: T::Boolean,
+            media_files: T::Array[T.anything],
+            previews: T::Array[T.anything],
+            price: Integer,
+            reply_to_message_id: Integer,
+            rf_guest: String,
+            rf_partner: String,
+            rf_tag: String,
+            text: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageSendResponse)
+        end
+        def send_(
+          # Path param: The ID of the chat (usually a fan's OnlyFans User ID)
+          chat_id,
+          # Path param: The Account ID
+          account:,
+          # Body param: The ID of the Giphy GIF to attach to the message. Get IDs from the
+          # Giphy listing endpoints (`/giphy/trending`, `/giphy/search`).
+          giphy_id: nil,
+          # Body param: Whether the text should be shown or hidden
+          locked_text: nil,
+          # Body param: Direct file uploads, OFAPI `ofapi_media_` IDs, or OF vault IDs. Will
+          # be hidden if `price` is provided.
+          media_files: nil,
+          # Body param: Direct file uploads, OFAPI `ofapi_media_` IDs, OF vault IDs, or
+          # integer indices referencing uploaded files in `mediaFiles`. Will be shown if
+          # `price` is provided.
+          previews: nil,
+          # Body param: Price for paid content (0 or between 3-200). In case this is not
+          # zero, **mediaFiles** is required
+          price: nil,
+          # Body param: Mark this message as a reply to another (can be either your own, or
+          # the recipient's)
+          reply_to_message_id: nil,
+          # Body param: Array of OnlyFans Release Form Guest IDs to tag in your message
+          rf_guest: nil,
+          # Body param: Array of OnlyFans Release Form Partners IDs to tag in your message
+          rf_partner: nil,
+          # Body param: Array of OnlyFans Creator User IDs to tag in your message
+          rf_tag: nil,
+          # Body param: The message text content. Required unless a media file is present.
+          text: nil,
+          request_options: {}
+        )
+        end
+
+        # Unlike a chat message.
+        sig do
+          params(
+            message_id: String,
+            account: String,
+            chat_id: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageUnlikeResponse)
+        end
+        def unlike(
+          # The ID of the message to unlike
+          message_id,
+          # The Account ID
+          account:,
+          # The ID of the chat, usually a fan's OnlyFans User ID
+          chat_id:,
+          request_options: {}
+        )
+        end
+
+        # Unpin a message from a chat.
+        sig do
+          params(
+            message_id: String,
+            account: String,
+            chat_id: String,
+            request_options: Onlyfans::RequestOptions::OrHash
+          ).returns(Onlyfans::Models::Chats::MessageUnpinResponse)
+        end
+        def unpin(
+          # The ID of the message to unpin
+          message_id,
+          # The Account ID
+          account:,
+          # The ID of the chat, usually a fan's OnlyFans User ID
+          chat_id:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Onlyfans::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/onlyfans/resources/chats.rbi

@@ -0,0 +1,204 @@
+# typed: strong
+
+module Onlyfans
+  module Resources
+    class Chats
+      sig { returns(Onlyfans::Resources::Chats::Messages) }
+      attr_reader :messages
+
+      sig { returns(Onlyfans::Resources::Chats::MarkAllAsRead) }
+      attr_reader :mark_all_as_read
+
+      # Get the list of chats for an Account.
+      sig do
+        params(
+          account: String,
+          filter: Onlyfans::ChatListParams::Filter::OrSymbol,
+          limit: String,
+          offset: String,
+          order: Onlyfans::ChatListParams::Order::OrSymbol,
+          query: String,
+          skip_users: Onlyfans::ChatListParams::SkipUsers::OrSymbol,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatListResponse)
+      end
+      def list(
+        # The Account ID
+        account,
+        # Optionally, filter the chats by type.
+        filter: nil,
+        # Number of chats to return (1 - 100). Default = 10
+        limit: nil,
+        # Number of chats to skip for pagination
+        offset: nil,
+        # Sort order for chats (recent or old). Default = recent
+        order: nil,
+        # Search query to filter chats
+        query: nil,
+        # Whether to skip user details in response (all or none). Default = all
+        skip_users: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete a specific chat.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatDeleteResponse)
+      end
+      def delete(
+        # The ID of the chat to delete, usually a fan's OnlyFans User ID
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # Hide a specific chat from the chat list. To unhide this chat, send a new message
+      # to the user.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatHideResponse)
+      end
+      def hide(
+        # The ID of the chat to hide, usually a fan's OnlyFans User ID
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # List media files shared in a specific chat.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          limit: String,
+          offset: String,
+          skip_users: String,
+          type: T.nilable(Onlyfans::ChatListMediaParams::Type::OrSymbol),
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatListMediaResponse)
+      end
+      def list_media(
+        # Path param: The ID of the chat to get media from, usually a fan's OnlyFans User
+        # ID
+        chat_id,
+        # Path param: The Account ID
+        account:,
+        # Query param: Number of medias to return. Default = 20
+        limit: nil,
+        # Query param: Number of medias to skip for pagination
+        offset: nil,
+        # Query param: Whether to skip user details in response (all or none). Default =
+        # all
+        skip_users: nil,
+        # Query param: Filter by specific media types. Keep empty to return all.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # Mark a specific chat as read. Alternative to List Chat Messages endpoint, if you
+      # just want to mark the chat as read without fetching messages.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatMarkAsReadResponse)
+      end
+      def mark_as_read(
+        # The ID of the chat to mark as read, usually a fan's OnlyFans User ID
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # Mark a specific chat as unread.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatMarkAsUnreadResponse)
+      end
+      def mark_as_unread(
+        # The ID of the chat to mark as read, usually a fan's OnlyFans User ID
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # Mute notifications for a specific chat.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatMuteResponse)
+      end
+      def mute(
+        # The ID of the chat to mute, usually a fan's OnlyFans User ID
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # Calling this endpoint will show the target fan a "Model is typing..." note in
+      # the chat for ~4 seconds. If you want to continue showing the indicator call this
+      # endpoint multiple times. Free - no credits charged.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatStartTypingResponse)
+      end
+      def start_typing(
+        # The ID of the chat (usually a fan's OnlyFans User ID)
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # Unmute notifications for a specific chat.
+      sig do
+        params(
+          chat_id: String,
+          account: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ChatUnmuteResponse)
+      end
+      def unmute(
+        # The ID of the chat to unmute, usually a fan's OnlyFans User ID
+        chat_id,
+        # The Account ID
+        account:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Onlyfans::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/onlyfans/resources/client_sessions.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Onlyfans
+  module Resources
+    class ClientSessions
+      # Create Client Session Token for later use in embedded auth components - eg. via
+      # @onlyfansapi/auth npm package.
+      sig do
+        params(
+          display_name: String,
+          client_reference_id: String,
+          proxy_country:
+            T.nilable(
+              Onlyfans::ClientSessionCreateParams::ProxyCountry::OrSymbol
+            ),
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::ClientSessionCreateResponse)
+      end
+      def create(
+        # Display Name of the account visible in your OnlyFansAPI Console Dashboard.
+        display_name:,
+        # Your Internal Reference ID for the connected account.
+        client_reference_id: nil,
+        proxy_country: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Onlyfans::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/onlyfans/resources/data_exports.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module Onlyfans
+  module Resources
+    # APIs for managing data exports
+    class DataExports
+      # Create a new data export request. This will calculate the required credits and
+      # prepare the export for starting.
+      sig do
+        params(
+          end_date: String,
+          file_type: Onlyfans::DataExportCreateParams::FileType::OrSymbol,
+          start_date: String,
+          type: Onlyfans::DataExportCreateParams::Type::OrSymbol,
+          account_ids: T::Array[String],
+          auto_start: T::Boolean,
+          export_columns: T::Array[String],
+          options: T::Hash[Symbol, T.anything],
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::DataExportCreateResponse)
+      end
+      def create(
+        # The end date for the export (ISO 8601 format).
+        end_date:,
+        # The output file format. Supported formats vary by export type: `csv` or `xlsx`
+        # for transactions, chat_messages, trial_links, tracking_links, smart_links,
+        # payouts, chargebacks, public_profiles, fans, followings; `zip` for media_vault.
+        file_type:,
+        # The start date for the export (ISO 8601 format).
+        start_date:,
+        # The type of data to export
+        type:,
+        # Array of account prefixed IDs to export data from. Not required for
+        # `public_profiles` type.
+        account_ids: nil,
+        # When true, automatically starts the export after creation.
+        auto_start: nil,
+        # Array of column names to include in the export (optional, defaults to all
+        # columns for the export type)
+        export_columns: nil,
+        # Type-specific export options. For `chat_messages`: `maxMessages` (required per
+        # account, max 10,000,000), `maxChats` (optional per-account chat scrape limit),
+        # `skipMassMessages` (optional, bool), `chatIds` (optional array of numeric
+        # fan/chat IDs; filters output and can drastically reduce totals). For
+        # `media_vault`: `mediaType` (required, one of: `all`, `photo`, `gif`, `video`,
+        # `audio`). For `fans`: `type` (required, one of: `all`, `active`, `expired`,
+        # `latest`). For `followings`: `type` (required, one of: `all`, `active`,
+        # `expired`). For `public_profiles`: `query` (optional, full-text search),
+        # `gender` (optional, filter: male, female, trans, couple), `minSubscribePrice`
+        # (optional, USD), `maxSubscribePrice` (optional, USD), `location` (optional),
+        # `minPostsCount` (optional, minimum posts), `minPhotosCount` (optional, minimum
+        # photos), `minVideosCount` (optional, minimum videos), `minSubscribersCount`
+        # (optional, minimum subscribers), `minJoinDate` (optional, ISO 8601 date),
+        # `minLastSeenAt` (optional, ISO 8601 date), `createdAtFrom` (optional, ISO 8601
+        # date, profile added to DB after), `createdAtTo` (optional, ISO 8601 date,
+        # profile added to DB before), `instagram` (optional), `twitter` (optional),
+        # `tiktok` (optional), `maxResults` (optional, limit results).
+        options: nil,
+        request_options: {}
+      )
+      end
+
+      # Get the current status and progress of a data export
+      sig do
+        params(
+          data_export_id: String,
+          download_url_expires_in: Integer,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::DataExportRetrieveResponse)
+      end
+      def retrieve(
+        # The prefixed ID of the data export
+        data_export_id,
+        # Number of minutes until the download URL expires. Min `1`, max `60`, default
+        # `5`.
+        download_url_expires_in: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated list of data exports for the team
+      sig do
+        params(
+          download_url_expires_in: Integer,
+          page: Integer,
+          per_page: Integer,
+          status: Onlyfans::DataExportListParams::Status::OrSymbol,
+          type: Onlyfans::DataExportListParams::Type::OrSymbol,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::DataExportListResponse)
+      end
+      def list(
+        # Number of minutes until download URLs expire. Min `1`, max `60`, default `5`.
+        download_url_expires_in: nil,
+        # Page number for pagination. Default `1`
+        page: nil,
+        # Number of results per page. Default `15`, max `100`
+        per_page: nil,
+        # Filter by status
+        status: nil,
+        # Filter by export type
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # Cancel a running data export. Only exports with status `pending` or
+      # `in_progress` can be cancelled.
+      sig do
+        params(
+          data_export_id: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::DataExportCancelResponse)
+      end
+      def cancel(
+        # The prefixed ID of the data export
+        data_export_id,
+        request_options: {}
+      )
+      end
+
+      # Create a new data export with the same parameters as a failed export and
+      # automatically start it.
+      sig do
+        params(
+          data_export_id: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::DataExportRetryResponse)
+      end
+      def retry_(
+        # The prefixed ID of the failed data export
+        data_export_id,
+        request_options: {}
+      )
+      end
+
+      # Start processing a data export that has completed credit calculation. This will
+      # begin the actual export process and charge credits.
+      sig do
+        params(
+          data_export_id: String,
+          request_options: Onlyfans::RequestOptions::OrHash
+        ).returns(Onlyfans::Models::DataExportStartResponse)
+      end
+      def start(
+        # The prefixed ID of the data export
+        data_export_id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Onlyfans::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end