post-for-me 0.1.0.pre.alpha.3

data/rbi/post_for_me/models/social_post_update_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module PostForMe
+  module Models
+    class SocialPostUpdateParams < PostForMe::Models::CreateSocialPost
+      extend PostForMe::Internal::Type::RequestParameters::Converter
+      include PostForMe::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(PostForMe::SocialPostUpdateParams, PostForMe::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: PostForMe::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: PostForMe::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/post_for_me/models/tiktok_configuration.rbi

@@ -0,0 +1,109 @@
+# typed: strong
+
+module PostForMe
+  module Models
+    class TiktokConfiguration < PostForMe::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(PostForMe::TiktokConfiguration, PostForMe::Internal::AnyHash)
+        end
+
+      # Allow comments on TikTok
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :allow_comment
+
+      # Allow duets on TikTok
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :allow_duet
+
+      # Allow stitch on TikTok
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :allow_stitch
+
+      # Overrides the `caption` from the post
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :caption
+
+      # Disclose branded content on TikTok
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :disclose_branded_content
+
+      # Disclose your brand on TikTok
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :disclose_your_brand
+
+      # Flag content as AI generated on TikTok
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_ai_generated
+
+      # Overrides the `media` from the post
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :media
+
+      # Sets the privacy status for TikTok (private, public)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :privacy_status
+
+      # Overrides the `title` from the post
+      sig { returns(T.nilable(String)) }
+      attr_accessor :title
+
+      sig do
+        params(
+          allow_comment: T.nilable(T::Boolean),
+          allow_duet: T.nilable(T::Boolean),
+          allow_stitch: T.nilable(T::Boolean),
+          caption: T.nilable(T.anything),
+          disclose_branded_content: T.nilable(T::Boolean),
+          disclose_your_brand: T.nilable(T::Boolean),
+          is_ai_generated: T.nilable(T::Boolean),
+          media: T.nilable(T::Array[String]),
+          privacy_status: T.nilable(String),
+          title: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Allow comments on TikTok
+        allow_comment: nil,
+        # Allow duets on TikTok
+        allow_duet: nil,
+        # Allow stitch on TikTok
+        allow_stitch: nil,
+        # Overrides the `caption` from the post
+        caption: nil,
+        # Disclose branded content on TikTok
+        disclose_branded_content: nil,
+        # Disclose your brand on TikTok
+        disclose_your_brand: nil,
+        # Flag content as AI generated on TikTok
+        is_ai_generated: nil,
+        # Overrides the `media` from the post
+        media: nil,
+        # Sets the privacy status for TikTok (private, public)
+        privacy_status: nil,
+        # Overrides the `title` from the post
+        title: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            allow_comment: T.nilable(T::Boolean),
+            allow_duet: T.nilable(T::Boolean),
+            allow_stitch: T.nilable(T::Boolean),
+            caption: T.nilable(T.anything),
+            disclose_branded_content: T.nilable(T::Boolean),
+            disclose_your_brand: T.nilable(T::Boolean),
+            is_ai_generated: T.nilable(T::Boolean),
+            media: T.nilable(T::Array[String]),
+            privacy_status: T.nilable(String),
+            title: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/post_for_me/models.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module PostForMe
+  CreateSocialPost = PostForMe::Models::CreateSocialPost
+
+  MediaCreateUploadURLParams = PostForMe::Models::MediaCreateUploadURLParams
+
+  SocialAccount = PostForMe::Models::SocialAccount
+
+  SocialAccountCreateAuthURLParams =
+    PostForMe::Models::SocialAccountCreateAuthURLParams
+
+  SocialAccountDisconnectParams =
+    PostForMe::Models::SocialAccountDisconnectParams
+
+  SocialAccountListParams = PostForMe::Models::SocialAccountListParams
+
+  SocialAccountRetrieveParams = PostForMe::Models::SocialAccountRetrieveParams
+
+  SocialAccountUpdateParams = PostForMe::Models::SocialAccountUpdateParams
+
+  SocialPost = PostForMe::Models::SocialPost
+
+  SocialPostCreateParams = PostForMe::Models::SocialPostCreateParams
+
+  SocialPostDeleteParams = PostForMe::Models::SocialPostDeleteParams
+
+  SocialPostListParams = PostForMe::Models::SocialPostListParams
+
+  SocialPostResult = PostForMe::Models::SocialPostResult
+
+  SocialPostResultListParams = PostForMe::Models::SocialPostResultListParams
+
+  SocialPostResultRetrieveParams =
+    PostForMe::Models::SocialPostResultRetrieveParams
+
+  SocialPostRetrieveParams = PostForMe::Models::SocialPostRetrieveParams
+
+  SocialPostUpdateParams = PostForMe::Models::SocialPostUpdateParams
+
+  TiktokConfiguration = PostForMe::Models::TiktokConfiguration
+end

data/rbi/post_for_me/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module PostForMe
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < PostForMe::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(PostForMe::RequestOptions, PostForMe::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: PostForMe::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: PostForMe::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/post_for_me/resources/media.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module PostForMe
+  module Resources
+    class Media
+      # To upload media to attach to your post, make a `POST` request to the
+      # `/media/create-upload-url` endpoint.
+      #
+      # You'll receive the public url of your media item (which can be used when making
+      # a post) and will include an `upload_url` which is a signed URL of the storage
+      # location for uploading your file to.
+      #
+      # This URL is unique and publicly signed for a short time, so make sure to upload
+      # your files in a timely manner.
+      #
+      # **Example flow using JavaScript and the Fetch API:**
+      #
+      # **Request an upload URL**
+      #
+      # ```js
+      # // Step 1: Request an upload URL from your API
+      # const response = await fetch(
+      #   "https://api.postforme.dev/v1/media/create-upload-url",
+      #   {
+      #     method: "POST",
+      #     headers: {
+      #       "Content-Type": "application/json",
+      #     },
+      #   }
+      # );
+      #
+      # const { media_url, upload_url } = await response.json();
+      # ```
+      #
+      # **Upload your file to the signed URL**
+      #
+      # ```js
+      # // Step 2: Upload your file to the signed URL
+      # const file = /* your File or Blob object, e.g., from an <input type="file"> */;
+      # await fetch(upload_url, {
+      #   method: 'PUT',
+      #   headers: {
+      #     'Content-Type': 'image/jpeg'
+      #   },
+      #   body: file
+      # });
+      # ```
+      #
+      # **Use the `media_url` when creating your post**
+      #
+      #     ```js
+      #     // Step 3: Use the `media_url` when creating your post
+      #     const response = await fetch('https://api.postforme.dev/v1/social-posts', {
+      #       method: 'POST',
+      #       headers: {
+      #         'Content-Type': 'application/json'
+      #       },
+      #       body: JSON.stringify({
+      #         social_accounts: ['spc_...', ...],
+      #         caption: 'My caption',
+      #         media: [
+      #           {
+      #             url: media_url
+      #           }
+      #         ]
+      #       })
+      #     });
+      #     ```
+      sig do
+        params(request_options: PostForMe::RequestOptions::OrHash).returns(
+          PostForMe::Models::MediaCreateUploadURLResponse
+        )
+      end
+      def create_upload_url(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: PostForMe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/post_for_me/resources/social_accounts.rbi

@@ -0,0 +1,112 @@
+# typed: strong
+
+module PostForMe
+  module Resources
+    class SocialAccounts
+      # Get social account by ID
+      sig do
+        params(
+          id: String,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::SocialAccount)
+      end
+      def retrieve(
+        # Social Account ID
+        id,
+        request_options: {}
+      )
+      end
+
+      # Update social account
+      sig do
+        params(
+          id: String,
+          external_id: String,
+          username: String,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::SocialAccount)
+      end
+      def update(
+        # Social Account ID
+        id,
+        # The platform's external id of the social account
+        external_id: nil,
+        # The platform's username of the social account
+        username: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated result for social accounts based on the applied filters
+      sig do
+        params(
+          id: T::Array[String],
+          external_id: T::Array[String],
+          limit: Float,
+          offset: Float,
+          platform: T::Array[String],
+          username: T::Array[String],
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::Models::SocialAccountListResponse)
+      end
+      def list(
+        # Filter by id(s). Multiple values imply OR logic (e.g.,
+        # ?id=spc_xxxxxx&id=spc_yyyyyy).
+        id: nil,
+        # Filter by externalId(s). Multiple values imply OR logic (e.g.,
+        # ?externalId=test&externalId=test2).
+        external_id: nil,
+        # Number of items to return
+        limit: nil,
+        # Number of items to skip
+        offset: nil,
+        # Filter by platform(s). Multiple values imply OR logic (e.g.,
+        # ?platform=x&platform=facebook).
+        platform: nil,
+        # Filter by username(s). Multiple values imply OR logic (e.g.,
+        # ?username=test&username=test2).
+        username: nil,
+        request_options: {}
+      )
+      end
+
+      # Generates a URL that initiates the authentication flow for a user's social media
+      # account. When visited, the user is redirected to the selected social platform's
+      # login/authorization page. Upon successful authentication, they are redirected
+      # back to your application
+      sig do
+        params(
+          platform: String,
+          platform_data:
+            PostForMe::SocialAccountCreateAuthURLParams::PlatformData::OrHash,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::Models::SocialAccountCreateAuthURLResponse)
+      end
+      def create_auth_url(
+        # The social account provider
+        platform:,
+        # Additional data needed for the provider
+        platform_data: nil,
+        request_options: {}
+      )
+      end
+
+      # Disconnecting an account with remove all auth tokens and mark the account as
+      # disconnected. The record of the account will be kept and can be retrieved and
+      # reconnected by the owner of the account.
+      sig do
+        params(
+          id: String,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::Models::SocialAccountDisconnectResponse)
+      end
+      def disconnect(id, request_options: {})
+      end
+
+      # @api private
+      sig { params(client: PostForMe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/post_for_me/resources/social_post_results.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module PostForMe
+  module Resources
+    class SocialPostResults
+      # Get post result by ID
+      sig do
+        params(
+          id: String,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::SocialPostResult)
+      end
+      def retrieve(
+        # Post Result ID
+        id,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated result for post results based on the applied filters
+      sig do
+        params(
+          limit: Float,
+          offset: Float,
+          platform: T::Array[String],
+          post_id: T::Array[String],
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::Models::SocialPostResultListResponse)
+      end
+      def list(
+        # Number of items to return
+        limit: nil,
+        # Number of items to skip
+        offset: nil,
+        # Filter by platform(s). Multiple values imply OR logic (e.g.,
+        # ?platform=x&platform=facebook).
+        platform: nil,
+        # Filter by post IDs. Multiple values imply OR logic (e.g.,
+        # ?post_id=123&post_id=456).
+        post_id: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: PostForMe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/post_for_me/resources/social_posts.rbi

@@ -0,0 +1,160 @@
+# typed: strong
+
+module PostForMe
+  module Resources
+    class SocialPosts
+      # Create Post
+      sig do
+        params(
+          caption: String,
+          social_accounts: T::Array[String],
+          account_configurations:
+            T.nilable(
+              T::Array[
+                PostForMe::CreateSocialPost::AccountConfiguration::OrHash
+              ]
+            ),
+          external_id: T.nilable(String),
+          is_draft: T.nilable(T::Boolean),
+          media:
+            T.nilable(T::Array[PostForMe::CreateSocialPost::Media::OrHash]),
+          platform_configurations:
+            T.nilable(
+              PostForMe::CreateSocialPost::PlatformConfigurations::OrHash
+            ),
+          scheduled_at: T.nilable(Time),
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::SocialPost)
+      end
+      def create(
+        # Caption text for the post
+        caption:,
+        # Array of social account IDs for posting
+        social_accounts:,
+        # Account-specific configurations for the post
+        account_configurations: nil,
+        # Array of social account IDs for posting
+        external_id: nil,
+        # If isDraft is set then the post will not be processed
+        is_draft: nil,
+        # Array of media URLs associated with the post
+        media: nil,
+        # Platform-specific configurations for the post
+        platform_configurations: nil,
+        # Scheduled date and time for the post, setting to null or undefined will post
+        # instantly
+        scheduled_at: nil,
+        request_options: {}
+      )
+      end
+
+      # Get Post by ID
+      sig do
+        params(
+          id: String,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::SocialPost)
+      end
+      def retrieve(
+        # Post ID
+        id,
+        request_options: {}
+      )
+      end
+
+      # Update Post
+      sig do
+        params(
+          id: String,
+          caption: String,
+          social_accounts: T::Array[String],
+          account_configurations:
+            T.nilable(
+              T::Array[
+                PostForMe::CreateSocialPost::AccountConfiguration::OrHash
+              ]
+            ),
+          external_id: T.nilable(String),
+          is_draft: T.nilable(T::Boolean),
+          media:
+            T.nilable(T::Array[PostForMe::CreateSocialPost::Media::OrHash]),
+          platform_configurations:
+            T.nilable(
+              PostForMe::CreateSocialPost::PlatformConfigurations::OrHash
+            ),
+          scheduled_at: T.nilable(Time),
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::SocialPost)
+      end
+      def update(
+        # Post ID
+        id,
+        # Caption text for the post
+        caption:,
+        # Array of social account IDs for posting
+        social_accounts:,
+        # Account-specific configurations for the post
+        account_configurations: nil,
+        # Array of social account IDs for posting
+        external_id: nil,
+        # If isDraft is set then the post will not be processed
+        is_draft: nil,
+        # Array of media URLs associated with the post
+        media: nil,
+        # Platform-specific configurations for the post
+        platform_configurations: nil,
+        # Scheduled date and time for the post, setting to null or undefined will post
+        # instantly
+        scheduled_at: nil,
+        request_options: {}
+      )
+      end
+
+      # Get a paginated result for posts based on the applied filters
+      sig do
+        params(
+          external_id: T::Array[String],
+          limit: Float,
+          offset: Float,
+          platform:
+            T::Array[PostForMe::SocialPostListParams::Platform::OrSymbol],
+          status: T::Array[PostForMe::SocialPostListParams::Status::OrSymbol],
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::Models::SocialPostListResponse)
+      end
+      def list(
+        # Filter by external ID. Multiple values imply OR logic.
+        external_id: nil,
+        # Number of items to return
+        limit: nil,
+        # Number of items to skip
+        offset: nil,
+        # Filter by platforms. Multiple values imply OR logic.
+        platform: nil,
+        # Filter by post status. Multiple values imply OR logic.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete Post
+      sig do
+        params(
+          id: String,
+          request_options: PostForMe::RequestOptions::OrHash
+        ).returns(PostForMe::Models::SocialPostDeleteResponse)
+      end
+      def delete(
+        # Post ID
+        id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: PostForMe::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/post_for_me/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module PostForMe
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/sig/post_for_me/client.rbs

@@ -0,0 +1,32 @@
+module PostForMe
+  class Client < PostForMe::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES: 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS: Float
+
+    DEFAULT_INITIAL_RETRY_DELAY: Float
+
+    DEFAULT_MAX_RETRY_DELAY: Float
+
+    attr_reader api_key: String
+
+    attr_reader media: PostForMe::Resources::Media
+
+    attr_reader social_posts: PostForMe::Resources::SocialPosts
+
+    attr_reader social_post_results: PostForMe::Resources::SocialPostResults
+
+    attr_reader social_accounts: PostForMe::Resources::SocialAccounts
+
+    private def auth_headers: -> ::Hash[String, String]
+
+    def initialize: (
+      ?api_key: String?,
+      ?base_url: String?,
+      ?max_retries: Integer,
+      ?timeout: Float,
+      ?initial_retry_delay: Float,
+      ?max_retry_delay: Float
+    ) -> void
+  end
+end