postproxy-sdk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 822ce030b347645daad188e55da76ab9a3494b0f7f01d0b6a78a02b4c9e933d6
+  data.tar.gz: 33dc5d8cf8e97817b9f6f69d8f57dd4dfd207ff1b8add0ba58661cddfd88f64f
+SHA512:
+  metadata.gz: 8460f568b415ec00973fa57d9065a85a141fe16aafb430765054ae51ca0ee16c514a55c02f59c54b7983def183c9131c07c65a5db448976f05d9db2139243915
+  data.tar.gz: 64c079b04bbd82dde18a2c612000ad42f8525351326714243c923dfde21bba6e51125006169a36675301b2fde2857f94c54e74cab08ae406345bf1dd8a26e711

data/README.md

@@ -0,0 +1,197 @@
+# PostProxy Ruby SDK
+
+Ruby client for the [PostProxy API](https://postproxy.dev) — manage social media posts, profiles, and profile groups.
+
+## Installation
+
+```bash
+gem install postproxy-sdk
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem "postproxy-sdk"
+```
+
+## Quick Start
+
+```ruby
+require "postproxy"
+
+client = PostProxy::Client.new("your-api-key", profile_group_id: "pg-abc")
+
+profiles = client.profiles.list.data
+post = client.posts.create(
+  "Hello from PostProxy!",
+  profiles: [profiles.first.id]
+)
+puts post.id, post.status
+```
+
+## Client
+
+```ruby
+# Basic
+client = PostProxy::Client.new("your-api-key")
+
+# With default profile group
+client = PostProxy::Client.new("your-api-key", profile_group_id: "pg-abc")
+
+# With custom base URL
+client = PostProxy::Client.new("your-api-key", base_url: "https://custom.api.dev")
+
+# With custom Faraday client
+faraday = Faraday.new(url: "https://api.postproxy.dev") do |f|
+  f.request :retry
+  f.headers["Authorization"] = "Bearer your-api-key"
+  f.adapter :net_http
+end
+client = PostProxy::Client.new("your-api-key", faraday_client: faraday)
+```
+
+## Posts
+
+```ruby
+# List posts (paginated)
+result = client.posts.list(page: 1, per_page: 10, status: "processed")
+result.data    # => [Post, ...]
+result.total   # => 42
+result.page    # => 1
+
+# Get a single post
+post = client.posts.get("post-id")
+
+# Create a post
+post = client.posts.create("Hello!", profiles: ["prof-1", "prof-2"])
+
+# Create with media URLs
+post = client.posts.create(
+  "Check this out!",
+  profiles: ["prof-1"],
+  media: ["https://example.com/image.jpg"]
+)
+
+# Create with local file uploads
+post = client.posts.create(
+  "Uploaded!",
+  profiles: ["prof-1"],
+  media_files: ["/path/to/photo.jpg"]
+)
+
+# Create a draft
+draft = client.posts.create("Draft", profiles: ["prof-1"], draft: true)
+
+# Publish a draft
+post = client.posts.publish_draft("post-id")
+
+# Schedule a post
+post = client.posts.create(
+  "Later!",
+  profiles: ["prof-1"],
+  scheduled_at: (Time.now + 3600).iso8601
+)
+
+# Delete a post
+client.posts.delete("post-id")
+```
+
+## Profiles
+
+```ruby
+# List profiles
+profiles = client.profiles.list.data
+
+# Get a profile
+profile = client.profiles.get("prof-id")
+
+# Get placements for a profile
+placements = client.profiles.placements("prof-id").data
+
+# Delete a profile
+client.profiles.delete("prof-id")
+```
+
+## Profile Groups
+
+```ruby
+# List groups
+groups = client.profile_groups.list.data
+
+# Get a group
+group = client.profile_groups.get("pg-id")
+
+# Create a group
+group = client.profile_groups.create("My Group")
+
+# Delete a group
+client.profile_groups.delete("pg-id")
+
+# Initialize OAuth connection
+connection = client.profile_groups.initialize_connection(
+  "pg-id",
+  platform: "instagram",
+  redirect_url: "https://myapp.com/callback"
+)
+# Redirect user to connection.url
+```
+
+## Platform Parameters
+
+```ruby
+platforms = PostProxy::PlatformParams.new(
+  facebook: PostProxy::FacebookParams.new(
+    format: "post",
+    first_comment: "First!"
+  ),
+  instagram: PostProxy::InstagramParams.new(
+    format: "reel",
+    collaborators: ["@friend"],
+    cover_url: "https://example.com/cover.jpg"
+  ),
+  tiktok: PostProxy::TikTokParams.new(
+    privacy_status: "PUBLIC_TO_EVERYONE",
+    auto_add_music: true
+  ),
+  linkedin: PostProxy::LinkedInParams.new(format: "post"),
+  youtube: PostProxy::YouTubeParams.new(
+    title: "My Video",
+    privacy_status: "public"
+  ),
+  pinterest: PostProxy::PinterestParams.new(
+    title: "My Pin",
+    board_id: "board-123"
+  ),
+  threads: PostProxy::ThreadsParams.new(format: "post"),
+  twitter: PostProxy::TwitterParams.new(format: "post")
+)
+
+post = client.posts.create(
+  "Cross-platform!",
+  profiles: ["prof-1", "prof-2"],
+  platforms: platforms
+)
+```
+
+## Error Handling
+
+```ruby
+begin
+  client.posts.get("bad-id")
+rescue PostProxy::AuthenticationError => e
+  puts "Auth failed: #{e.message}"       # 401
+rescue PostProxy::NotFoundError => e
+  puts "Not found: #{e.message}"          # 404
+rescue PostProxy::ValidationError => e
+  puts "Invalid: #{e.message}"            # 422
+rescue PostProxy::BadRequestError => e
+  puts "Bad request: #{e.message}"        # 400
+rescue PostProxy::Error => e
+  puts "Error #{e.status_code}: #{e.message}"
+  puts e.response  # parsed response body
+end
+```
+
+## License
+
+MIT

data/lib/postproxy/client.rb

@@ -0,0 +1,155 @@
+require "faraday"
+require "faraday/multipart"
+require "json"
+require_relative "resources/posts"
+require_relative "resources/profiles"
+require_relative "resources/profile_groups"
+
+module PostProxy
+  class Client
+    attr_reader :api_key, :base_url, :profile_group_id
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, profile_group_id: nil, faraday_client: nil)
+      @api_key = api_key
+      @base_url = base_url
+      @profile_group_id = profile_group_id
+      @faraday_client = faraday_client
+      @posts = nil
+      @profiles = nil
+      @profile_groups = nil
+    end
+
+    def posts
+      @posts ||= Resources::Posts.new(self)
+    end
+
+    def profiles
+      @profiles ||= Resources::Profiles.new(self)
+    end
+
+    def profile_groups
+      @profile_groups ||= Resources::ProfileGroups.new(self)
+    end
+
+    def request(method, path, params: nil, json: nil, data: nil, files: nil, profile_group_id: nil)
+      url = "/api#{path}"
+
+      query = {}
+      pgid = profile_group_id || @profile_group_id
+      query[:profile_group_id] = pgid if pgid
+      query.merge!(params) if params
+
+      response = if files
+                   conn = multipart_connection
+                   parts = []
+                   data&.each { |k, v| parts << [k.to_s, v.to_s] }
+                   files.each do |field, filename, io, content_type|
+                     if io.nil?
+                       # Plain text part (filename holds the string value)
+                       parts << [field, filename]
+                     elsif io.is_a?(String)
+                       # Plain text part
+                       parts << [field, io]
+                     else
+                       # File upload
+                       parts << [field, Faraday::Multipart::FilePart.new(io, content_type, filename)]
+                     end
+                   end
+                   # Build payload preserving duplicate keys
+                   payload = parts.each_with_object({}) do |(key, val), h|
+                     if h.key?(key)
+                       h[key] = [h[key]] unless h[key].is_a?(Array)
+                       h[key] << val
+                     else
+                       h[key] = val
+                     end
+                   end
+                   conn.send(method, url) do |req|
+                     req.params = query unless query.empty?
+                     req.body = payload
+                   end
+                 else
+                   conn = json_connection
+                   conn.send(method, url) do |req|
+                     req.params = query unless query.empty?
+                     req.body = json.to_json if json
+                   end
+                 end
+
+      handle_response(response)
+    end
+
+    private
+
+    def json_connection
+      @faraday_client || Faraday.new(url: @base_url) do |f|
+        f.request :url_encoded
+        f.headers["Authorization"] = "Bearer #{@api_key}"
+        f.headers["Content-Type"] = "application/json"
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def multipart_connection
+      @faraday_client || Faraday.new(url: @base_url) do |f|
+        f.request :multipart
+        f.headers["Authorization"] = "Bearer #{@api_key}"
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        return nil if response.status == 204
+        return nil if response.body.nil? || response.body.empty?
+        JSON.parse(response.body, symbolize_names: true)
+      when 401
+        body = parse_error_body(response)
+        raise AuthenticationError.new(
+          error_message(body),
+          status_code: response.status,
+          response: body
+        )
+      when 404
+        body = parse_error_body(response)
+        raise NotFoundError.new(
+          error_message(body),
+          status_code: response.status,
+          response: body
+        )
+      when 422
+        body = parse_error_body(response)
+        raise ValidationError.new(
+          error_message(body),
+          status_code: response.status,
+          response: body
+        )
+      when 400
+        body = parse_error_body(response)
+        raise BadRequestError.new(
+          error_message(body),
+          status_code: response.status,
+          response: body
+        )
+      else
+        body = parse_error_body(response)
+        raise Error.new(
+          error_message(body),
+          status_code: response.status,
+          response: body
+        )
+      end
+    end
+
+    def parse_error_body(response)
+      JSON.parse(response.body, symbolize_names: true)
+    rescue JSON::ParserError, TypeError
+      { error: response.body }
+    end
+
+    def error_message(body)
+      body[:message] || body[:error]
+    end
+  end
+end

data/lib/postproxy/constants.rb

@@ -0,0 +1,28 @@
+module PostProxy
+  DEFAULT_BASE_URL = "https://api.postproxy.dev"
+
+  PLATFORMS = %w[
+    facebook instagram tiktok linkedin youtube twitter threads pinterest
+  ].freeze
+
+  PROFILE_STATUSES = %w[active expired inactive].freeze
+
+  POST_STATUSES = %w[pending draft processing processed scheduled].freeze
+
+  PLATFORM_POST_STATUSES = %w[pending processing published failed deleted].freeze
+
+  INSTAGRAM_FORMATS = %w[post reel story].freeze
+  FACEBOOK_FORMATS = %w[post story].freeze
+  TIKTOK_FORMATS = %w[video image].freeze
+  LINKEDIN_FORMATS = %w[post].freeze
+  YOUTUBE_FORMATS = %w[post].freeze
+  PINTEREST_FORMATS = %w[pin].freeze
+  THREADS_FORMATS = %w[post].freeze
+  TWITTER_FORMATS = %w[post].freeze
+
+  TIKTOK_PRIVACIES = %w[
+    PUBLIC_TO_EVERYONE MUTUAL_FOLLOW_FRIENDS FOLLOWER_OF_CREATOR SELF_ONLY
+  ].freeze
+
+  YOUTUBE_PRIVACIES = %w[public unlisted private].freeze
+end

data/lib/postproxy/errors.rb

@@ -0,0 +1,16 @@
+module PostProxy
+  class Error < StandardError
+    attr_reader :status_code, :response
+
+    def initialize(message, status_code: nil, response: nil)
+      super(message)
+      @status_code = status_code
+      @response = response
+    end
+  end
+
+  class AuthenticationError < Error; end
+  class NotFoundError < Error; end
+  class ValidationError < Error; end
+  class BadRequestError < Error; end
+end

data/lib/postproxy/resources/posts.rb

@@ -0,0 +1,117 @@
+module PostProxy
+  module Resources
+    class Posts
+      def initialize(client)
+        @client = client
+      end
+
+      def list(page: nil, per_page: nil, status: nil, platforms: nil, scheduled_after: nil, profile_group_id: nil)
+        params = {}
+        params[:page] = page if page
+        params[:per_page] = per_page if per_page
+        params[:status] = status if status
+        params[:platforms] = platforms.join(",") if platforms
+        params[:scheduled_after] = format_time(scheduled_after) if scheduled_after
+
+        result = @client.request(:get, "/posts", params: params, profile_group_id: profile_group_id)
+        posts = (result[:data] || []).map { |p| Post.new(**p) }
+        PaginatedResponse.new(
+          data: posts,
+          total: result[:total],
+          page: result[:page],
+          per_page: result[:per_page]
+        )
+      end
+
+      def get(id, profile_group_id: nil)
+        result = @client.request(:get, "/posts/#{id}", profile_group_id: profile_group_id)
+        Post.new(**result)
+      end
+
+      def create(body, profiles:, media: nil, media_files: nil, platforms: nil,
+                 scheduled_at: nil, draft: nil, profile_group_id: nil)
+        if media_files && !media_files.empty?
+          form_data = { "post[body]" => body }
+          form_data["post[scheduled_at]"] = format_time(scheduled_at) if scheduled_at
+          form_data["post[draft]"] = draft.to_s if !draft.nil?
+
+          files = []
+
+          profiles.each do |p|
+            files << ["profiles[]", nil, p, "text/plain"]
+          end
+
+          media&.each do |m|
+            files << ["media[]", nil, m, "text/plain"]
+          end
+
+          if platforms
+            params_hash = platforms.is_a?(PlatformParams) ? platforms.to_h : platforms
+            params_hash.each do |platform, platform_params|
+              platform_params.each do |key, value|
+                files << ["platforms[#{platform}][#{key}]", nil, value.to_s, "text/plain"]
+              end
+            end
+          end
+
+          media_files.each do |path|
+            path = path.to_s
+            filename = File.basename(path)
+            content_type = mime_type_for(filename)
+            io = File.open(path, "rb")
+            files << ["media[]", filename, io, content_type]
+          end
+
+          result = @client.request(:post, "/posts",
+            data: form_data,
+            files: files,
+            profile_group_id: profile_group_id
+          )
+        else
+          post_payload = { body: body }
+          post_payload[:scheduled_at] = format_time(scheduled_at) if scheduled_at
+          post_payload[:draft] = draft unless draft.nil?
+
+          json_body = { post: post_payload, profiles: profiles }
+          json_body[:platforms] = platforms.is_a?(PlatformParams) ? platforms.to_h : platforms if platforms
+          json_body[:media] = media if media
+
+          result = @client.request(:post, "/posts", json: json_body, profile_group_id: profile_group_id)
+        end
+
+        Post.new(**result)
+      end
+
+      def publish_draft(id, profile_group_id: nil)
+        result = @client.request(:post, "/posts/#{id}/publish", profile_group_id: profile_group_id)
+        Post.new(**result)
+      end
+
+      def delete(id, profile_group_id: nil)
+        result = @client.request(:delete, "/posts/#{id}", profile_group_id: profile_group_id)
+        DeleteResponse.new(**result)
+      end
+
+      private
+
+      def format_time(value)
+        return value if value.is_a?(String)
+        value.iso8601
+      end
+
+      def mime_type_for(filename)
+        case File.extname(filename).downcase
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".png" then "image/png"
+        when ".gif" then "image/gif"
+        when ".webp" then "image/webp"
+        when ".mp4" then "video/mp4"
+        when ".mov" then "video/quicktime"
+        when ".avi" then "video/x-msvideo"
+        when ".webm" then "video/webm"
+        else "application/octet-stream"
+        end
+      end
+    end
+  end
+end

data/lib/postproxy/resources/profile_groups.rb

@@ -0,0 +1,37 @@
+module PostProxy
+  module Resources
+    class ProfileGroups
+      def initialize(client)
+        @client = client
+      end
+
+      def list
+        result = @client.request(:get, "/profile_groups")
+        groups = (result[:data] || []).map { |g| ProfileGroup.new(**g) }
+        ListResponse.new(data: groups)
+      end
+
+      def get(id)
+        result = @client.request(:get, "/profile_groups/#{id}")
+        ProfileGroup.new(**result)
+      end
+
+      def create(name)
+        result = @client.request(:post, "/profile_groups", json: { name: name })
+        ProfileGroup.new(**result)
+      end
+
+      def delete(id)
+        result = @client.request(:delete, "/profile_groups/#{id}")
+        DeleteResponse.new(**result)
+      end
+
+      def initialize_connection(id, platform:, redirect_url:)
+        result = @client.request(:post, "/profile_groups/#{id}/initialize_connection",
+          json: { platform: platform, redirect_url: redirect_url }
+        )
+        ConnectionResponse.new(**result)
+      end
+    end
+  end
+end

data/lib/postproxy/resources/profiles.rb

@@ -0,0 +1,31 @@
+module PostProxy
+  module Resources
+    class Profiles
+      def initialize(client)
+        @client = client
+      end
+
+      def list(profile_group_id: nil)
+        result = @client.request(:get, "/profiles", profile_group_id: profile_group_id)
+        profiles = (result[:data] || []).map { |p| Profile.new(**p) }
+        ListResponse.new(data: profiles)
+      end
+
+      def get(id, profile_group_id: nil)
+        result = @client.request(:get, "/profiles/#{id}", profile_group_id: profile_group_id)
+        Profile.new(**result)
+      end
+
+      def placements(id, profile_group_id: nil)
+        result = @client.request(:get, "/profiles/#{id}/placements", profile_group_id: profile_group_id)
+        items = (result[:data] || []).map { |p| Placement.new(**p) }
+        ListResponse.new(data: items)
+      end
+
+      def delete(id, profile_group_id: nil)
+        result = @client.request(:delete, "/profiles/#{id}", profile_group_id: profile_group_id)
+        SuccessResponse.new(**result)
+      end
+    end
+  end
+end

data/lib/postproxy/types.rb

@@ -0,0 +1,197 @@
+require "time"
+
+module PostProxy
+  class Model
+    def initialize(**attrs)
+      attrs.each do |key, value|
+        if respond_to?(:"#{key}=")
+          send(:"#{key}=", value)
+        end
+      end
+    end
+
+    def to_h
+      instance_variables.each_with_object({}) do |var, hash|
+        key = var.to_s.delete_prefix("@")
+        hash[key.to_sym] = instance_variable_get(var)
+      end
+    end
+  end
+
+  class Profile < Model
+    attr_accessor :id, :name, :status, :platform, :profile_group_id, :expires_at, :post_count
+
+    def initialize(**attrs)
+      @expires_at = nil
+      @post_count = 0
+      super
+      @expires_at = parse_time(@expires_at)
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      value.is_a?(Time) ? value : Time.parse(value.to_s)
+    end
+  end
+
+  class ProfileGroup < Model
+    attr_accessor :id, :name, :profiles_count
+
+    def initialize(**attrs)
+      @profiles_count = 0
+      super
+    end
+  end
+
+  class Insights < Model
+    attr_accessor :impressions, :on
+
+    def initialize(**attrs)
+      @impressions = nil
+      @on = nil
+      super
+      @on = parse_time(@on)
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      value.is_a?(Time) ? value : Time.parse(value.to_s)
+    end
+  end
+
+  class PlatformResult < Model
+    attr_accessor :platform, :status, :params, :error, :attempted_at, :insights
+
+    def initialize(**attrs)
+      @params = nil
+      @error = nil
+      @attempted_at = nil
+      @insights = nil
+      super
+      @attempted_at = parse_time(@attempted_at)
+      @insights = Insights.new(**@insights) if @insights.is_a?(Hash)
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      value.is_a?(Time) ? value : Time.parse(value.to_s)
+    end
+  end
+
+  class Post < Model
+    attr_accessor :id, :body, :status, :scheduled_at, :created_at, :platforms
+
+    def initialize(**attrs)
+      @scheduled_at = nil
+      @platforms = []
+      super
+      @scheduled_at = parse_time(@scheduled_at)
+      @created_at = parse_time(@created_at)
+      @platforms = (@platforms || []).map do |p|
+        p.is_a?(PlatformResult) ? p : PlatformResult.new(**p.transform_keys(&:to_sym))
+      end
+    end
+
+    private
+
+    def parse_time(value)
+      return nil if value.nil?
+      value.is_a?(Time) ? value : Time.parse(value.to_s)
+    end
+  end
+
+  class Placement < Model
+    attr_accessor :id, :name
+  end
+
+  class ListResponse
+    attr_reader :data
+
+    def initialize(data:)
+      @data = data
+    end
+  end
+
+  class PaginatedResponse < ListResponse
+    attr_reader :total, :page, :per_page
+
+    def initialize(data:, total:, page:, per_page:)
+      super(data: data)
+      @total = total
+      @page = page
+      @per_page = per_page
+    end
+  end
+
+  class DeleteResponse < Model
+    attr_accessor :deleted
+  end
+
+  class SuccessResponse < Model
+    attr_accessor :success
+  end
+
+  class ConnectionResponse < Model
+    attr_accessor :url, :success
+  end
+
+  # Platform-specific parameter structs
+
+  class FacebookParams < Model
+    attr_accessor :format, :first_comment, :page_id
+  end
+
+  class InstagramParams < Model
+    attr_accessor :format, :first_comment, :collaborators, :cover_url,
+                  :audio_name, :trial_strategy, :thumb_offset
+  end
+
+  class TikTokParams < Model
+    attr_accessor :format, :privacy_status, :photo_cover_index, :auto_add_music,
+                  :made_with_ai, :disable_comment, :disable_duet, :disable_stitch,
+                  :brand_content_toggle, :brand_organic_toggle
+  end
+
+  class LinkedInParams < Model
+    attr_accessor :format, :organization_id
+  end
+
+  class YouTubeParams < Model
+    attr_accessor :format, :title, :privacy_status, :cover_url
+  end
+
+  class PinterestParams < Model
+    attr_accessor :format, :title, :board_id, :destination_link, :cover_url, :thumb_offset
+  end
+
+  class ThreadsParams < Model
+    attr_accessor :format
+  end
+
+  class TwitterParams < Model
+    attr_accessor :format
+  end
+
+  class PlatformParams < Model
+    attr_accessor :facebook, :instagram, :tiktok, :linkedin, :youtube,
+                  :pinterest, :threads, :twitter
+
+    def to_h
+      result = {}
+      %i[facebook instagram tiktok linkedin youtube pinterest threads twitter].each do |platform|
+        value = send(platform)
+        next if value.nil?
+
+        params = value.is_a?(Model) ? value.to_h : value
+        result[platform] = params.reject { |_, v| v.nil? }
+      end
+      result
+    end
+  end
+end

data/lib/postproxy/version.rb

@@ -0,0 +1,3 @@
+module PostProxy
+  VERSION = "1.0.0"
+end

data/lib/postproxy.rb

@@ -0,0 +1,8 @@
+require_relative "postproxy/version"
+require_relative "postproxy/constants"
+require_relative "postproxy/errors"
+require_relative "postproxy/types"
+require_relative "postproxy/client"
+
+module PostProxy
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: postproxy-sdk
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- PostProxy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby client for the PostProxy API — manage social media posts, profiles,
+  and profile groups.
+email:
+- support@postproxy.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/postproxy.rb
+- lib/postproxy/client.rb
+- lib/postproxy/constants.rb
+- lib/postproxy/errors.rb
+- lib/postproxy/resources/posts.rb
+- lib/postproxy/resources/profile_groups.rb
+- lib/postproxy/resources/profiles.rb
+- lib/postproxy/types.rb
+- lib/postproxy/version.rb
+homepage: https://postproxy.dev
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://postproxy.dev
+  source_code_uri: https://github.com/postproxy/postproxy-ruby
+  documentation_uri: https://postproxy.dev/getting-started/overview/
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Ruby client for the PostProxy API
+test_files: []