renamed 0.1.0.beta.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77538a9c46e4722a2be7b056217e87e168464c54317be54c8139cbdf0d5f7a6e
+  data.tar.gz: 03b4a3515b130d8d8eed9b47f2d7a2c083c4c9e05388051432ca3748c90d4abe
+SHA512:
+  metadata.gz: 3e1cce89fe45835b1eff235248236cf7229a86cb0f10d79fedd758670a6e5a352476a518baf498fac4cad04e2c93af0be809fecbe9ccdcd386f2355e0c01c06c
+  data.tar.gz: 32ce22cb167093c9770cd6ff79aa3d96701bd3099ff060d445189877f534a0991ba1324e9b2d3d1803618c7e532a2f8a376018d76fdc07c0aec61791ade83611

data/README.md

@@ -0,0 +1,218 @@
+# Renamed Ruby SDK
+
+Official Ruby SDK for the [renamed.to](https://renamed.to) API. Rename files intelligently using AI, split PDFs, and extract structured data from documents.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'renamed'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install renamed
+```
+
+## Quick Start
+
+```ruby
+require 'renamed'
+
+# Initialize the client with your API key
+client = Renamed::Client.new(api_key: 'rt_your_api_key')
+
+# Rename a file using AI
+result = client.rename('invoice.pdf')
+puts result.suggested_filename  # => "2025-01-15_AcmeCorp_INV-12345.pdf"
+puts result.folder_path         # => "Invoices/2025/January"
+```
+
+## Features
+
+### Rename Files
+
+Intelligently rename files using AI analysis:
+
+```ruby
+# Basic rename
+result = client.rename('document.pdf')
+puts result.suggested_filename
+puts result.folder_path
+puts result.confidence
+
+# With custom template
+result = client.rename('invoice.pdf', template: '{date}_{vendor}_{type}')
+puts result.suggested_filename
+```
+
+### Split PDFs
+
+Split multi-page PDFs into separate documents:
+
+```ruby
+# Auto-detect document boundaries
+job = client.pdf_split('multi-page.pdf', mode: 'auto')
+
+# Wait for completion with progress updates
+result = job.wait do |status|
+  puts "Progress: #{status.progress}%"
+end
+
+# Download the split documents
+result.documents.each do |doc|
+  puts "#{doc.filename} (pages #{doc.pages})"
+  content = client.download_file(doc.download_url)
+  File.binwrite(doc.filename, content)
+end
+
+# Split by fixed page count
+job = client.pdf_split('document.pdf', mode: 'pages', pages_per_split: 5)
+result = job.wait
+
+# Split at blank pages
+job = client.pdf_split('scanned.pdf', mode: 'blank')
+result = job.wait
+```
+
+### Extract Data
+
+Extract structured data from documents:
+
+```ruby
+# Extract with natural language prompt
+result = client.extract('invoice.pdf', prompt: 'Extract the vendor name, invoice number, and total amount')
+puts result.data
+# => {"vendor" => "Acme Corp", "invoice_number" => "INV-12345", "total" => 1250.00}
+
+# Extract with JSON schema
+schema = {
+  type: 'object',
+  properties: {
+    vendor: { type: 'string' },
+    invoice_number: { type: 'string' },
+    line_items: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          description: { type: 'string' },
+          quantity: { type: 'number' },
+          price: { type: 'number' }
+        }
+      }
+    },
+    total: { type: 'number' }
+  }
+}
+
+result = client.extract('invoice.pdf', schema: schema)
+puts result.data
+puts result.confidence
+```
+
+### Check User Credits
+
+```ruby
+user = client.get_user
+puts "Email: #{user.email}"
+puts "Credits remaining: #{user.credits}"
+puts "Team: #{user.team&.name}"
+```
+
+## Configuration
+
+```ruby
+client = Renamed::Client.new(
+  api_key: 'rt_your_api_key',
+  base_url: 'https://www.renamed.to/api/v1',  # Default
+  timeout: 30,                                  # Request timeout in seconds
+  max_retries: 2                                # Number of retries for failed requests
+)
+```
+
+## Error Handling
+
+The SDK provides specific error classes for different error conditions:
+
+```ruby
+begin
+  result = client.rename('document.pdf')
+rescue Renamed::AuthenticationError => e
+  puts "Invalid API key: #{e.message}"
+rescue Renamed::InsufficientCreditsError => e
+  puts "Not enough credits: #{e.message}"
+rescue Renamed::RateLimitError => e
+  puts "Rate limited. Retry after: #{e.retry_after} seconds"
+rescue Renamed::ValidationError => e
+  puts "Invalid request: #{e.message}"
+  puts "Details: #{e.details}"
+rescue Renamed::NetworkError => e
+  puts "Network error: #{e.message}"
+rescue Renamed::TimeoutError => e
+  puts "Request timed out: #{e.message}"
+rescue Renamed::JobError => e
+  puts "Job failed: #{e.message}"
+  puts "Job ID: #{e.job_id}"
+rescue Renamed::Error => e
+  puts "General error: #{e.message}"
+  puts "Code: #{e.code}"
+  puts "Status: #{e.status_code}"
+end
+```
+
+## File Input Types
+
+All file methods accept multiple input types:
+
+```ruby
+# String path
+result = client.rename('/path/to/document.pdf')
+
+# File object
+File.open('document.pdf', 'rb') do |file|
+  result = client.rename(file)
+end
+
+# IO object
+io = StringIO.new(pdf_content)
+result = client.rename(io)
+```
+
+## Supported File Types
+
+- PDF (`.pdf`)
+- JPEG (`.jpg`, `.jpeg`)
+- PNG (`.png`)
+- TIFF (`.tif`, `.tiff`)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+To generate documentation:
+
+```bash
+bundle exec yard doc
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/renamed-to/renamed-sdk.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/renamed/async_job.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "models"
+require_relative "errors"
+
+module Renamed
+  # Async job handle for long-running operations like PDF split.
+  class AsyncJob
+    DEFAULT_POLL_INTERVAL = 2.0
+    MAX_POLL_ATTEMPTS = 150 # 5 minutes at 2s intervals
+
+    attr_reader :status_url
+
+    # @param client [Client] The Renamed client instance
+    # @param status_url [String] URL to poll for job status
+    # @param poll_interval [Float] Interval between status checks in seconds
+    # @param max_attempts [Integer] Maximum number of polling attempts
+    def initialize(client, status_url, poll_interval: DEFAULT_POLL_INTERVAL, max_attempts: MAX_POLL_ATTEMPTS)
+      @client = client
+      @status_url = status_url
+      @poll_interval = poll_interval
+      @max_attempts = max_attempts
+    end
+
+    # Get current job status.
+    #
+    # @return [JobStatusResponse] Current job status
+    def status
+      response = @client.send(:request, :get, @status_url)
+      JobStatusResponse.from_response(response)
+    end
+
+    # Wait for job completion, polling at regular intervals.
+    #
+    # @yield [JobStatusResponse] Called with status updates during polling
+    # @return [PdfSplitResult] The completed job result
+    # @raise [JobError] If the job fails or times out
+    #
+    # @example Wait for job completion
+    #   job = client.pdf_split("multi-page.pdf", mode: "auto")
+    #   result = job.wait { |status| puts "Progress: #{status.progress}%" }
+    #   result.documents.each do |doc|
+    #     puts "#{doc.filename}: #{doc.download_url}"
+    #   end
+    def wait
+      attempts = 0
+
+      while attempts < @max_attempts
+        current_status = status
+
+        yield current_status if block_given?
+
+        if current_status.status == "completed" && current_status.result
+          return current_status.result
+        end
+
+        if current_status.status == "failed"
+          raise JobError.new(current_status.error || "Job failed", job_id: current_status.job_id)
+        end
+
+        attempts += 1
+        sleep(@poll_interval)
+      end
+
+      raise JobError.new("Job polling timeout exceeded")
+    end
+  end
+end

data/lib/renamed/client.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "json"
+
+require_relative "errors"
+require_relative "models"
+require_relative "async_job"
+
+module Renamed
+  # renamed.to API client.
+  #
+  # @example Basic usage
+  #   client = Renamed::Client.new(api_key: "rt_your_api_key")
+  #   result = client.rename("invoice.pdf")
+  #   puts result.suggested_filename
+  #
+  # @example With custom configuration
+  #   client = Renamed::Client.new(
+  #     api_key: "rt_your_api_key",
+  #     timeout: 60,
+  #     max_retries: 3
+  #   )
+  class Client
+    DEFAULT_BASE_URL = "https://www.renamed.to/api/v1"
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_MAX_RETRIES = 2
+
+    # @param api_key [String] API key for authentication (starts with rt_)
+    # @param base_url [String] Base URL for the API
+    # @param timeout [Integer] Request timeout in seconds
+    # @param max_retries [Integer] Maximum number of retries for failed requests
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT, max_retries: DEFAULT_MAX_RETRIES)
+      raise AuthenticationError, "API key is required" if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @timeout = timeout
+      @max_retries = max_retries
+
+      @connection = build_connection
+    end
+
+    # Get current user profile and credits.
+    #
+    # @return [User] User profile with credits balance
+    #
+    # @example
+    #   user = client.get_user
+    #   puts "Credits remaining: #{user.credits}"
+    def get_user
+      response = request(:get, "/user")
+      User.from_response(response)
+    end
+
+    # Rename a file using AI.
+    #
+    # @param file [String, File, IO] File to rename (path, File object, or IO)
+    # @param options [Hash] Additional options
+    # @option options [String] :template Custom template for filename generation
+    #
+    # @return [RenameResult] Result with suggested filename and folder path
+    #
+    # @example Rename a file by path
+    #   result = client.rename("invoice.pdf")
+    #   puts result.suggested_filename  # "2025-01-15_AcmeCorp_INV-12345.pdf"
+    #
+    # @example Rename with custom template
+    #   result = client.rename("invoice.pdf", template: "{date}_{vendor}_{type}")
+    #   puts result.suggested_filename
+    def rename(file, options: {})
+      additional_fields = {}
+      additional_fields["template"] = options[:template] if options[:template]
+
+      response = upload_file("/rename", file, additional_fields: additional_fields)
+      RenameResult.from_response(response)
+    end
+
+    # Split a PDF into multiple documents.
+    #
+    # Returns an AsyncJob that can be polled for completion.
+    #
+    # @param file [String, File, IO] PDF file to split
+    # @param options [Hash] Additional options
+    # @option options [String] :mode Split mode ('auto', 'pages', or 'blank')
+    # @option options [Integer] :pages_per_split Number of pages per split (for 'pages' mode)
+    #
+    # @return [AsyncJob] Job that can be waited on for the result
+    #
+    # @example Split a PDF with auto-detection
+    #   job = client.pdf_split("multi-page.pdf", mode: "auto")
+    #   result = job.wait { |s| puts "Progress: #{s.progress}%" }
+    #   result.documents.each do |doc|
+    #     puts "#{doc.filename}: #{doc.download_url}"
+    #   end
+    #
+    # @example Split into fixed page chunks
+    #   job = client.pdf_split("document.pdf", mode: "pages", pages_per_split: 5)
+    #   result = job.wait
+    def pdf_split(file, options: {})
+      additional_fields = {}
+      additional_fields["mode"] = options[:mode] if options[:mode]
+      additional_fields["pagesPerSplit"] = options[:pages_per_split].to_s if options[:pages_per_split]
+
+      response = upload_file("/pdf-split", file, additional_fields: additional_fields)
+      AsyncJob.new(self, response["statusUrl"])
+    end
+
+    # Extract structured data from a document.
+    #
+    # @param file [String, File, IO] Document to extract data from
+    # @param options [Hash] Additional options
+    # @option options [String] :prompt Natural language description of what to extract
+    # @option options [Hash] :schema JSON schema defining the structure of data to extract
+    #
+    # @return [ExtractResult] Result with extracted data
+    #
+    # @example Extract with a prompt
+    #   result = client.extract("invoice.pdf", prompt: "Extract invoice details")
+    #   puts result.data
+    #
+    # @example Extract with a schema
+    #   schema = {
+    #     type: "object",
+    #     properties: {
+    #       vendor: { type: "string" },
+    #       total: { type: "number" }
+    #     }
+    #   }
+    #   result = client.extract("invoice.pdf", schema: schema)
+    def extract(file, options: {})
+      additional_fields = {}
+      additional_fields["prompt"] = options[:prompt] if options[:prompt]
+      additional_fields["schema"] = JSON.generate(options[:schema]) if options[:schema]
+
+      response = upload_file("/extract", file, additional_fields: additional_fields)
+      ExtractResult.from_response(response)
+    end
+
+    # Download a file from a URL (e.g., split document).
+    #
+    # @param url [String] URL to download from
+    # @return [String] File content as binary string
+    #
+    # @example Download split documents
+    #   result = job.wait
+    #   result.documents.each do |doc|
+    #     content = client.download_file(doc.download_url)
+    #     File.binwrite(doc.filename, content)
+    #   end
+    def download_file(url)
+      response = @connection.get(url)
+      handle_download_response(response)
+    end
+
+    private
+
+    def build_connection
+      Faraday.new(url: @base_url) do |conn|
+        conn.request :multipart
+        conn.request :url_encoded
+        conn.headers["Authorization"] = "Bearer #{@api_key}"
+        conn.options.timeout = @timeout
+        conn.options.open_timeout = @timeout
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def build_url(path)
+      return path if path.start_with?("http://", "https://")
+
+      path = "/#{path}" unless path.start_with?("/")
+      "#{@base_url}#{path}"
+    end
+
+    def request(method, path, **options)
+      url = build_url(path)
+      last_error = nil
+      attempts = 0
+
+      while attempts <= @max_retries
+        begin
+          response = @connection.send(method, url, options[:body], options[:headers])
+          return handle_response(response)
+        rescue Faraday::ConnectionFailed => e
+          last_error = NetworkError.new(e.message)
+        rescue Faraday::TimeoutError => e
+          last_error = TimeoutError.new(e.message)
+        rescue Renamed::Error => e
+          # Don't retry client errors (4xx)
+          raise if e.status_code && e.status_code >= 400 && e.status_code < 500
+
+          last_error = e
+        end
+
+        attempts += 1
+        sleep(2**attempts * 0.1) if attempts <= @max_retries
+      end
+
+      raise last_error || NetworkError.new
+    end
+
+    def handle_response(response)
+      if response.status >= 400
+        payload = parse_response_body(response)
+        raise Renamed.error_from_http_status(response.status, response.reason_phrase || "Error", payload)
+      end
+
+      parse_response_body(response)
+    end
+
+    def handle_download_response(response)
+      if response.status >= 400
+        raise Renamed.error_from_http_status(response.status, response.reason_phrase || "Error")
+      end
+
+      response.body
+    end
+
+    def parse_response_body(response)
+      return {} if response.body.nil? || response.body.empty?
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      response.body
+    end
+
+    def upload_file(path, file, additional_fields: {})
+      filename, content, mime_type = prepare_file(file)
+
+      payload = {}
+      payload[:file] = Faraday::Multipart::FilePart.new(
+        StringIO.new(content),
+        mime_type,
+        filename
+      )
+
+      additional_fields.each do |key, value|
+        payload[key] = value
+      end
+
+      url = build_url(path)
+      last_error = nil
+      attempts = 0
+
+      while attempts <= @max_retries
+        begin
+          response = @connection.post(url, payload)
+          return handle_response(response)
+        rescue Faraday::ConnectionFailed => e
+          last_error = NetworkError.new(e.message)
+        rescue Faraday::TimeoutError => e
+          last_error = TimeoutError.new(e.message)
+        rescue Renamed::Error => e
+          raise if e.status_code && e.status_code >= 400 && e.status_code < 500
+
+          last_error = e
+        end
+
+        attempts += 1
+        sleep(2**attempts * 0.1) if attempts <= @max_retries
+      end
+
+      raise last_error || NetworkError.new
+    end
+
+    def prepare_file(file)
+      case file
+      when String
+        # File path
+        path = File.expand_path(file)
+        content = File.binread(path)
+        filename = File.basename(path)
+        [filename, content, get_mime_type(filename)]
+      when File, IO
+        content = file.read
+        filename = file.respond_to?(:path) && file.path ? File.basename(file.path) : "file"
+        [filename, content, get_mime_type(filename)]
+      else
+        raise ValidationError.new("Invalid file input: expected String path, File, or IO object")
+      end
+    end
+
+    def get_mime_type(filename)
+      ext = File.extname(filename).downcase
+      MIME_TYPES[ext] || "application/octet-stream"
+    end
+  end
+end

data/lib/renamed/errors.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Renamed
+  # Base exception for all renamed.to SDK errors.
+  class Error < StandardError
+    attr_reader :message, :code, :status_code, :details
+
+    def initialize(message = "An error occurred", code: "UNKNOWN_ERROR", status_code: nil, details: nil)
+      @message = message
+      @code = code
+      @status_code = status_code
+      @details = details
+      super(message)
+    end
+  end
+
+  # Authentication error - invalid or missing API key.
+  class AuthenticationError < Error
+    def initialize(message = "Invalid or missing API key")
+      super(message, code: "AUTHENTICATION_ERROR", status_code: 401)
+    end
+  end
+
+  # Insufficient credits error.
+  class InsufficientCreditsError < Error
+    def initialize(message = "Insufficient credits")
+      super(message, code: "INSUFFICIENT_CREDITS", status_code: 402)
+    end
+  end
+
+  # Rate limit exceeded.
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message = "Rate limit exceeded", retry_after: nil)
+      super(message, code: "RATE_LIMIT_ERROR", status_code: 429)
+      @retry_after = retry_after
+    end
+  end
+
+  # Validation error - invalid request parameters.
+  class ValidationError < Error
+    def initialize(message, details: nil)
+      super(message, code: "VALIDATION_ERROR", status_code: 400, details: details)
+    end
+  end
+
+  # Network error - connection failed.
+  class NetworkError < Error
+    def initialize(message = "Network request failed")
+      super(message, code: "NETWORK_ERROR")
+    end
+  end
+
+  # Timeout error - request took too long.
+  class TimeoutError < Error
+    def initialize(message = "Request timed out")
+      super(message, code: "TIMEOUT_ERROR")
+    end
+  end
+
+  # Job error - async job failed.
+  class JobError < Error
+    attr_reader :job_id
+
+    def initialize(message, job_id: nil)
+      super(message, code: "JOB_ERROR")
+      @job_id = job_id
+    end
+  end
+
+  # Create appropriate error from HTTP status code.
+  #
+  # @param status [Integer] HTTP status code
+  # @param status_text [String] HTTP status text
+  # @param payload [Hash, String, nil] Response payload
+  # @return [Error] Appropriate error instance
+  def self.error_from_http_status(status, status_text, payload = nil)
+    message = status_text
+    if payload.is_a?(Hash) && payload["error"]
+      message = payload["error"].to_s
+    end
+
+    case status
+    when 401
+      AuthenticationError.new(message)
+    when 402
+      InsufficientCreditsError.new(message)
+    when 400, 422
+      ValidationError.new(message, details: payload)
+    when 429
+      retry_after = payload.is_a?(Hash) ? payload["retryAfter"] : nil
+      RateLimitError.new(message, retry_after: retry_after)
+    else
+      Error.new(message, code: "API_ERROR", status_code: status, details: payload)
+    end
+  end
+end

data/lib/renamed/models.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Renamed
+  # Result of a rename operation.
+  class RenameResult
+    attr_reader :original_filename, :suggested_filename, :folder_path, :confidence
+
+    # @param original_filename [String] Original filename that was uploaded
+    # @param suggested_filename [String] AI-suggested new filename
+    # @param folder_path [String, nil] Suggested folder path for organization
+    # @param confidence [Float, nil] Confidence score (0-1) of the suggestion
+    def initialize(original_filename:, suggested_filename:, folder_path: nil, confidence: nil)
+      @original_filename = original_filename
+      @suggested_filename = suggested_filename
+      @folder_path = folder_path
+      @confidence = confidence
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param data [Hash] API response data
+    # @return [RenameResult]
+    def self.from_response(data)
+      new(
+        original_filename: data["originalFilename"],
+        suggested_filename: data["suggestedFilename"],
+        folder_path: data["folderPath"],
+        confidence: data["confidence"]
+      )
+    end
+
+    def to_h
+      {
+        original_filename: @original_filename,
+        suggested_filename: @suggested_filename,
+        folder_path: @folder_path,
+        confidence: @confidence
+      }.compact
+    end
+  end
+
+  # A single document from PDF split.
+  class SplitDocument
+    attr_reader :index, :filename, :pages, :download_url, :size
+
+    # @param index [Integer] Document index (0-based)
+    # @param filename [String] Suggested filename for this document
+    # @param pages [String] Page range included in this document
+    # @param download_url [String] URL to download this document
+    # @param size [Integer] Size in bytes
+    def initialize(index:, filename:, pages:, download_url:, size:)
+      @index = index
+      @filename = filename
+      @pages = pages
+      @download_url = download_url
+      @size = size
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param data [Hash] API response data
+    # @return [SplitDocument]
+    def self.from_response(data)
+      new(
+        index: data["index"],
+        filename: data["filename"],
+        pages: data["pages"],
+        download_url: data["downloadUrl"],
+        size: data["size"]
+      )
+    end
+
+    def to_h
+      {
+        index: @index,
+        filename: @filename,
+        pages: @pages,
+        download_url: @download_url,
+        size: @size
+      }
+    end
+  end
+
+  # Result of PDF split operation.
+  class PdfSplitResult
+    attr_reader :original_filename, :documents, :total_pages
+
+    # @param original_filename [String] Original filename
+    # @param documents [Array<SplitDocument>] Split documents
+    # @param total_pages [Integer] Total number of pages in original document
+    def initialize(original_filename:, documents:, total_pages:)
+      @original_filename = original_filename
+      @documents = documents
+      @total_pages = total_pages
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param data [Hash] API response data
+    # @return [PdfSplitResult]
+    def self.from_response(data)
+      documents = (data["documents"] || []).map { |doc| SplitDocument.from_response(doc) }
+      new(
+        original_filename: data["originalFilename"],
+        documents: documents,
+        total_pages: data["totalPages"]
+      )
+    end
+
+    def to_h
+      {
+        original_filename: @original_filename,
+        documents: @documents.map(&:to_h),
+        total_pages: @total_pages
+      }
+    end
+  end
+
+  # Response from job status endpoint.
+  class JobStatusResponse
+    attr_reader :job_id, :status, :progress, :error, :result
+
+    # @param job_id [String] Unique job identifier
+    # @param status [String] Current job status (pending, processing, completed, failed)
+    # @param progress [Integer, nil] Progress percentage (0-100)
+    # @param error [String, nil] Error message if job failed
+    # @param result [PdfSplitResult, nil] Result data when job is completed
+    def initialize(job_id:, status:, progress: nil, error: nil, result: nil)
+      @job_id = job_id
+      @status = status
+      @progress = progress
+      @error = error
+      @result = result
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param data [Hash] API response data
+    # @return [JobStatusResponse]
+    def self.from_response(data)
+      result = data["result"] ? PdfSplitResult.from_response(data["result"]) : nil
+      new(
+        job_id: data["jobId"],
+        status: data["status"],
+        progress: data["progress"],
+        error: data["error"],
+        result: result
+      )
+    end
+
+    def to_h
+      {
+        job_id: @job_id,
+        status: @status,
+        progress: @progress,
+        error: @error,
+        result: @result&.to_h
+      }.compact
+    end
+  end
+
+  # Result of extract operation.
+  class ExtractResult
+    attr_reader :data, :confidence
+
+    # @param data [Hash] Extracted data matching the schema
+    # @param confidence [Float] Confidence score (0-1)
+    def initialize(data:, confidence:)
+      @data = data
+      @confidence = confidence
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param response_data [Hash] API response data
+    # @return [ExtractResult]
+    def self.from_response(response_data)
+      new(
+        data: response_data["data"],
+        confidence: response_data["confidence"]
+      )
+    end
+
+    def to_h
+      {
+        data: @data,
+        confidence: @confidence
+      }
+    end
+  end
+
+  # Team information.
+  class Team
+    attr_reader :id, :name
+
+    # @param id [String] Team ID
+    # @param name [String] Team name
+    def initialize(id:, name:)
+      @id = id
+      @name = name
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param data [Hash] API response data
+    # @return [Team]
+    def self.from_response(data)
+      new(
+        id: data["id"],
+        name: data["name"]
+      )
+    end
+
+    def to_h
+      {
+        id: @id,
+        name: @name
+      }
+    end
+  end
+
+  # User profile information.
+  class User
+    attr_reader :id, :email, :name, :credits, :team
+
+    # @param id [String] User ID
+    # @param email [String] Email address
+    # @param name [String, nil] Display name
+    # @param credits [Integer, nil] Available credits
+    # @param team [Team, nil] Team information (if applicable)
+    def initialize(id:, email:, name: nil, credits: nil, team: nil)
+      @id = id
+      @email = email
+      @name = name
+      @credits = credits
+      @team = team
+    end
+
+    # Create instance from API response hash.
+    #
+    # @param data [Hash] API response data
+    # @return [User]
+    def self.from_response(data)
+      team = data["team"] ? Team.from_response(data["team"]) : nil
+      new(
+        id: data["id"],
+        email: data["email"],
+        name: data["name"],
+        credits: data["credits"],
+        team: team
+      )
+    end
+
+    def to_h
+      {
+        id: @id,
+        email: @email,
+        name: @name,
+        credits: @credits,
+        team: @team&.to_h
+      }.compact
+    end
+  end
+
+  # MIME types for supported file formats.
+  MIME_TYPES = {
+    ".pdf" => "application/pdf",
+    ".jpg" => "image/jpeg",
+    ".jpeg" => "image/jpeg",
+    ".png" => "image/png",
+    ".tiff" => "image/tiff",
+    ".tif" => "image/tiff"
+  }.freeze
+end

data/lib/renamed/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Renamed
+  VERSION = "0.1.0.beta.2"
+end

data/lib/renamed.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "renamed/version"
+require_relative "renamed/errors"
+require_relative "renamed/models"
+require_relative "renamed/async_job"
+require_relative "renamed/client"
+
+# Official Ruby SDK for renamed.to API.
+#
+# @example Basic usage
+#   require "renamed"
+#
+#   client = Renamed::Client.new(api_key: "rt_your_api_key")
+#
+#   # Rename a file
+#   result = client.rename("invoice.pdf")
+#   puts result.suggested_filename
+#
+#   # Check credits
+#   user = client.get_user
+#   puts "Credits: #{user.credits}"
+#
+# @see https://renamed.to/docs API Documentation
+module Renamed
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: renamed
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta.2
+platform: ruby
+authors:
+- renamed.to
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-11 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'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.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'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Ruby client library for the renamed.to API. Rename files intelligently
+  using AI, split PDFs, and extract structured data from documents.
+email:
+- support@renamed.to
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/renamed.rb
+- lib/renamed/async_job.rb
+- lib/renamed/client.rb
+- lib/renamed/errors.rb
+- lib/renamed/models.rb
+- lib/renamed/version.rb
+homepage: https://renamed.to
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://renamed.to
+  source_code_uri: https://github.com/renamed-to/renamed-sdk
+  changelog_uri: https://github.com/renamed-to/renamed-sdk/blob/main/sdks/ruby/CHANGELOG.md
+  documentation_uri: https://renamed.to/docs
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for renamed.to API
+test_files: []