reclaim 0.2.0

data/lib/reclaim/cli.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Reclaim
+  # CLI Interface
+  class CLI
+    def self.add_task_arguments(parser, options)
+      parser.on('--title TITLE', 'Task title') { |v| options[:title] = v }
+      parser.on('--due DUE', 'Due date (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS, or "none" to clear)') do |v|
+        options[:due_date] = parse_clearable_date(v)
+      end
+      parser.on('--priority PRIORITY', ['P1', 'P2', 'P3', 'P4'], 'Task priority') { |v| options[:priority] = v.downcase.to_sym }
+      parser.on('--duration DURATION', Float, 'Task duration in hours') { |v| options[:duration] = v }
+      parser.on('--min-chunk MIN', Float, 'Minimum chunk size in hours') { |v| options[:min_chunk_size] = v }
+      parser.on('--max-chunk MAX', Float, 'Maximum chunk size in hours') { |v| options[:max_chunk_size] = v }
+      parser.on('--min-work MIN', Float, 'Minimum work duration in hours') { |v| options[:min_work_duration] = v }
+      parser.on('--max-work MAX', Float, 'Maximum work duration in hours') { |v| options[:max_work_duration] = v }
+      parser.on('--snooze DATETIME', 'Start after this date/time (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS, or "none" to clear)') do |v|
+        options[:snooze_until] = parse_clearable_date(v)
+      end
+      parser.on('--defer DATETIME', 'Start after this date/time (synonym for --snooze, or "none" to clear)') do |v|
+        options[:snooze_until] = parse_clearable_date(v)
+      end
+      parser.on('--start DATETIME', 'Specific start time (YYYY-MM-DDTHH:MM:SS, or "none" to clear)') do |v|
+        options[:start] = parse_clearable_date(v)
+      end
+      parser.on('--time-scheme SCHEME', 'Time scheme ID or name (e.g., "work", "personal", "Work Hours", or UUID)') { |v| options[:time_scheme] = v }
+      parser.on('--split [CHUNK_SIZE]', 'Allow task to be split into smaller chunks. Optional: specify min chunk size in hours (e.g. 0.5 for 30min)') do |v|
+        options[:allow_splitting] = true
+        options[:split_chunk_size] = v.to_f if v && v.to_f > 0
+      end
+      parser.on('--private PRIVATE', 'Make task private (true/false)') do |v|
+        options[:always_private] = case v.downcase
+                                   when 'true', '1', 'yes', 'y' then true
+                                   when 'false', '0', 'no', 'n' then false
+                                   else
+                                     puts "✗ Invalid value for --private. Use true/false"
+                                     exit(1)
+                                   end
+      end
+      parser.on('--category CATEGORY', 'Event category') { |v| options[:event_category] = v }
+      parser.on('--color COLOR', 'Event color') { |v| options[:event_color] = v }
+      parser.on('--notes NOTES', 'Task notes/description') { |v| options[:notes] = v }
+    end
+
+    # Parse date values that can be cleared with special keywords
+    def self.parse_clearable_date(value)
+      return nil if value.nil?
+      # Handle special clear keywords
+      return nil if ['none', 'clear', 'null', ''].include?(value.downcase.strip)
+      # Otherwise return the date string as-is for the API to parse
+      value
+    end
+
+    def self.show_help_and_exit(message = nil)
+      puts "✗ #{message}" if message
+      puts <<~HELP
+        Reclaim Task CRUD Operations
+
+        Usage: reclaim [COMMAND] [OPTIONS]
+
+        Commands:
+          list [FILTER]           List tasks (optional filter: active, completed, overdue)
+                                  (default: lists active tasks when no command given)
+          create                  Create a new task (requires --title)
+          get TASK_ID            Get task details
+          update TASK_ID         Update a task
+          complete TASK_ID       Mark task as complete (ARCHIVED status)
+          delete TASK_ID         Delete a task (permanent deletion)
+          list-schemes           List available time schemes
+          help                   Show this help message
+
+        Task Options:
+          --title TITLE          Task title
+          --due DATE             Due date (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS, or "none" to clear)
+          --priority PRIORITY    Task priority (P1, P2, P3, P4)
+          --duration HOURS       Task duration in hours (e.g., 0.25 for 15min, 1.5 for 90min)
+          --split [CHUNK_SIZE]   Allow task splitting. Optional: min chunk size in hours (default: no splitting)
+          --min-chunk HOURS      Minimum chunk size in hours (only with --split)
+          --max-chunk HOURS      Maximum chunk size in hours (only with --split)
+          --min-work HOURS       Minimum work duration in hours
+          --max-work HOURS       Maximum work duration in hours
+          --defer DATE           Start after this date/time (synonym for --snooze, or "none" to clear)
+          --snooze DATE          Start after this date/time (or "none" to clear)
+          --start DATE           Specific start time (or "none" to clear)
+          --time-scheme SCHEME   Time scheme ID or name
+          --private BOOL         Make task private (true/false)
+          --category CATEGORY    Event category
+          --color COLOR          Event color
+          --notes TEXT           Task notes/description
+
+        Clearing Dates:
+          Use "none", "clear", or "null" as the value to remove a date field.
+          Examples:
+            reclaim update abc123 --due none           # Clear due date
+            reclaim update abc123 --defer clear        # Clear deferred start date
+            reclaim update abc123 --start null         # Clear specific start time
+
+        Time Scheme Aliases:
+          work, working hours, business hours  → Finds schemes containing 'work'
+          personal, off hours, private         → Finds schemes containing 'personal'
+
+        Status Values:
+          SCHEDULED, IN_PROGRESS, COMPLETE (still active), ARCHIVED (truly complete)
+
+        ID Tracking for GTD Integration:
+          Store Reclaim task IDs in NEXT.md as [Reclaim:id] for sync operations.
+
+        Examples:
+          reclaim                                   # Lists active tasks (default)
+          reclaim list active                       # Lists active tasks (explicit)
+          reclaim list completed                    # Lists completed tasks
+          reclaim create --title "Important Work" --due 2025-08-15 --priority P1 --duration 2
+          reclaim create --title "Research" --duration 3 --split 0.5  # Allow splitting with 30min minimum chunks
+          reclaim create --title "Deep Work" --duration 4             # No splitting (default)
+          reclaim update abc123 --title "Updated Title" --priority P2
+          reclaim complete abc123
+          reclaim list-schemes
+      HELP
+      exit(0)
+    end
+
+    def self.run
+      command = ARGV.shift || 'list'
+
+      # Handle help flag
+      if command == '--help' || command == '-h'
+        command = 'help'
+      end
+
+      # If no command provided, default to listing active tasks
+      if command == 'list' && ARGV.empty?
+        ARGV.unshift('active')
+      end
+
+      begin
+        client = Reclaim::Client.new
+      rescue AuthenticationError => e
+        puts "✗ #{e.message}"
+        exit(1)
+      end
+
+      case command
+      when 'list'
+        filter = ARGV.shift
+        if filter && !['active', 'completed', 'overdue'].include?(filter)
+          show_help_and_exit("Invalid filter '#{filter}'. Valid options: active, completed, overdue")
+        end
+        list_tasks(client, filter&.to_sym)
+
+      when 'create'
+        options = {}
+        parser = OptionParser.new
+        add_task_arguments(parser, options)
+        parser.parse!(ARGV)
+
+        show_help_and_exit("Task title is required. Use --title TITLE") if options[:title].nil?
+
+        create_task(client, options)
+
+      when 'get'
+        task_id = ARGV.shift
+        show_help_and_exit("Task ID is required") if task_id.nil?
+        get_task(client, task_id)
+
+      when 'update'
+        task_id = ARGV.shift
+        show_help_and_exit("Task ID is required") if task_id.nil?
+
+        options = {}
+        parser = OptionParser.new
+        add_task_arguments(parser, options)
+        parser.parse!(ARGV)
+
+        show_help_and_exit("No update fields provided") if options.empty?
+        update_task(client, task_id, options)
+
+      when 'complete'
+        task_id = ARGV.shift
+        show_help_and_exit("Task ID is required") if task_id.nil?
+        complete_task(client, task_id)
+
+      when 'delete'
+        task_id = ARGV.shift
+        show_help_and_exit("Task ID is required") if task_id.nil?
+        delete_task(client, task_id)
+
+      when 'list-schemes'
+        help_aliases = false
+        parser = OptionParser.new
+        parser.on('--help-aliases', 'Show common aliases for time schemes') { help_aliases = true }
+        parser.parse!(ARGV)
+
+        list_time_schemes(client, help_aliases)
+
+      when 'help'
+        show_help_and_exit
+
+      else
+        show_help_and_exit("Unknown command '#{command}'")
+      end
+
+    rescue StandardError => e
+      puts "✗ Error: #{e.message}"
+      exit(1)
+    end
+
+    # CLI command implementations
+    def self.list_tasks(client, filter = nil)
+      tasks = client.list_tasks(filter: filter)
+
+      if tasks.empty?
+        puts "No tasks found#{filter ? " matching filter '#{filter}'" : ''}."
+        return
+      end
+
+      puts "\nYour Reclaim Tasks#{filter ? " (#{filter})" : ''}:"
+      puts '-' * 50
+
+      tasks.each do |task|
+        status_icon = task.completed? ? '✓' : '○'
+        due_str = task.due_date ? " (due: #{task.due_date_formatted})" : ''
+
+        puts "#{status_icon} #{task.title}#{due_str}"
+        puts "   ID: #{task.id} | Priority: #{task.priority} | Status: #{task.status}"
+      end
+
+      puts "\nTotal: #{tasks.length} tasks"
+    end
+
+    def self.create_task(client, options)
+      task = client.create_task(**options)
+      puts "✓ Created task: #{task.title} (ID: #{task.id})"
+    rescue InvalidRecordError => e
+      puts "✗ Error creating task: #{e.message}"
+      exit(1)
+    end
+
+    def self.get_task(client, task_id)
+      task = client.get_task(task_id)
+
+      puts "\nTask: #{task.title}"
+      puts "ID: #{task.id}"
+      puts "Priority: #{task.priority}"
+      puts "Status: #{task.status}"
+      puts "Duration: #{task.duration} hours" if task.duration
+      puts "Due: #{task.due_date_formatted}" if task.due_date
+      puts "Time Scheme: #{task.time_scheme_id}" if task.time_scheme_id
+      puts "Private: #{task.always_private}" if task.always_private
+      puts "Category: #{task.event_category}" if task.event_category
+      puts "Color: #{task.event_color}" if task.event_color
+      puts "Notes: #{task.notes}" if task.notes && !task.notes.empty?
+    rescue NotFoundError
+      puts "✗ Task #{task_id} not found"
+      exit(1)
+    end
+
+    def self.update_task(client, task_id, options)
+      task = client.update_task(task_id, **options)
+      puts "✓ Updated task: #{task.title}"
+    rescue NotFoundError
+      puts "✗ Task #{task_id} not found"
+      exit(1)
+    rescue InvalidRecordError => e
+      puts "✗ Error updating task: #{e.message}"
+      exit(1)
+    end
+
+    def self.complete_task(client, task_id)
+      task = client.complete_task(task_id)
+      puts "✓ Completed task: #{task.title}"
+    rescue NotFoundError
+      puts "✗ Task #{task_id} not found"
+      exit(1)
+    end
+
+    def self.delete_task(client, task_id)
+      client.delete_task(task_id)
+      puts "✓ Deleted task: #{task_id}"
+    rescue NotFoundError
+      puts "✗ Task #{task_id} not found"
+      exit(1)
+    end
+
+    def self.list_time_schemes(client, help_aliases = false)
+      puts client.format_time_schemes
+
+      if help_aliases
+        puts "\nCommon Aliases:"
+        puts "• work, working hours, business hours → Finds schemes containing 'work'"
+        puts "• personal, off hours, off-hours, private → Finds schemes containing 'personal'"
+        puts "• You can also use partial matches (e.g., 'Work' matches 'Work Hours')"
+      end
+    end
+  end
+end

data/lib/reclaim/client.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+require 'openssl'
+
+module Reclaim
+  # HTTP client for Reclaim API interactions
+  class Client
+    BASE_URL = 'https://api.app.reclaim.ai/api'
+
+    def initialize(token = nil)
+      @token = token || ENV['RECLAIM_API_KEY']
+      raise AuthenticationError, 'RECLAIM_API_KEY environment variable not set' unless @token
+
+      @time_schemes_cache = nil
+    end
+
+    # Create a new task
+    def create_task(title:, due_date: nil, priority: :p3, duration: 1.0,
+                    min_chunk_size: nil, max_chunk_size: nil, min_work_duration: nil,
+                    max_work_duration: nil, snooze_until: nil, start: nil,
+                    time_scheme: nil, always_private: nil, event_category: nil,
+                    event_color: nil, notes: nil, allow_splitting: false, split_chunk_size: nil)
+
+      # Resolve time scheme if provided
+      time_scheme_id = time_scheme ? resolve_time_scheme_id(time_scheme) : nil
+      if time_scheme && !time_scheme_id
+        raise InvalidRecordError, "Time scheme '#{time_scheme}' not found. Use list_time_schemes to see available options."
+      end
+
+      # Set chunk sizes based on splitting preference
+      duration_chunks = (duration * 4).to_i # Convert hours to 15-minute chunks
+      if allow_splitting
+        # Allow splitting: use provided chunk sizes or defaults
+        # Use split_chunk_size if provided, otherwise use min_chunk_size or default
+        if split_chunk_size
+          min_chunk = (split_chunk_size * 4).to_i
+        elsif min_chunk_size
+          min_chunk = (min_chunk_size * 4).to_i
+        else
+          min_chunk = 1 # Default 15 minutes
+        end
+
+        max_chunk = max_chunk_size ? (max_chunk_size * 4).to_i : 12 # Default 3 hours
+      else
+        # Prevent splitting: set both min and max to full duration
+        min_chunk = duration_chunks
+        max_chunk = duration_chunks
+      end
+
+      task_data = {
+        title: title,
+        priority: Task::PRIORITIES[priority] || 'P3',
+        timeChunksRequired: duration_chunks,
+        eventCategory: event_category || 'WORK',
+        eventSubType: 'FOCUS',
+        minChunkSize: min_chunk,
+        maxChunkSize: max_chunk
+      }
+
+      # Add optional fields (using actual API field names)
+      task_data[:due] = Utils.format_datetime_for_api(due_date) if due_date
+      task_data[:notes] = notes if notes
+      # Note: minChunkSize and maxChunkSize are now set above based on allow_splitting
+      task_data[:minWorkDuration] = (min_work_duration * 4).to_i if min_work_duration
+      task_data[:maxWorkDuration] = (max_work_duration * 4).to_i if max_work_duration
+      task_data[:snoozeUntil] = Utils.format_datetime_for_api(snooze_until) if snooze_until
+      task_data[:start] = Utils.format_datetime_for_api(start) if start
+      task_data[:timeSchemeId] = time_scheme_id if time_scheme_id
+      task_data[:alwaysPrivate] = always_private if always_private
+      task_data[:eventCategory] = event_category if event_category
+      task_data[:eventColor] = event_color if event_color
+
+      response = make_request(:post, '/tasks', task_data)
+      Task.new(response)
+    end
+
+    # List all tasks with optional filtering
+    def list_tasks(filter: nil)
+      response = make_request(:get, '/tasks')
+      tasks = response.map { |task_data| Task.new(task_data) }
+
+      # Apply client-side filtering since API doesn't support server-side filtering
+      case filter
+      when :active
+        tasks.select(&:active?)
+      when :completed
+        tasks.select(&:completed?)
+      when :overdue
+        tasks.select(&:overdue?)
+      else
+        tasks
+      end
+    end
+
+    # Get a specific task by ID
+    def get_task(task_id)
+      response = make_request(:get, "/tasks/#{task_id}")
+      Task.new(response)
+    rescue ApiError => e
+      raise NotFoundError, "Task #{task_id} not found" if e.status_code == 404
+
+      raise
+    end
+
+    # Update an existing task
+    def update_task(task_id, title: nil, notes: nil, priority: nil, due_date: :unset,
+                    duration: nil, min_chunk_size: nil, max_chunk_size: nil,
+                    min_work_duration: nil, max_work_duration: nil, snooze_until: :unset,
+                    start: :unset, time_scheme: nil, always_private: nil,
+                    event_category: nil, event_color: nil)
+
+      # Build update data with only provided fields
+      # Use :unset as sentinel to distinguish "not provided" from "explicitly nil (clear)"
+      update_data = {}
+
+      update_data[:title] = title if title
+      update_data[:notes] = notes if notes
+      update_data[:priority] = Task::PRIORITIES[priority] if priority
+
+      # Handle dates: :unset means not provided, nil means clear, value means set
+      if due_date != :unset
+        update_data[:due] = due_date.nil? ? nil : Utils.format_datetime_for_api(due_date)
+      end
+
+      update_data[:timeChunksRequired] = (duration * 4).to_i if duration
+      update_data[:minChunkSize] = (min_chunk_size * 4).to_i if min_chunk_size
+      update_data[:maxChunkSize] = (max_chunk_size * 4).to_i if max_chunk_size
+      update_data[:minWorkDuration] = (min_work_duration * 4).to_i if min_work_duration
+      update_data[:maxWorkDuration] = (max_work_duration * 4).to_i if max_work_duration
+
+      # Handle snooze_until (deferred date)
+      if snooze_until != :unset
+        update_data[:snoozeUntil] = snooze_until.nil? ? nil : Utils.format_datetime_for_api(snooze_until)
+      end
+
+      # Handle start date
+      if start != :unset
+        update_data[:start] = start.nil? ? nil : Utils.format_datetime_for_api(start)
+      end
+
+      update_data[:alwaysPrivate] = always_private if always_private
+      update_data[:eventCategory] = event_category if event_category
+      update_data[:eventColor] = event_color if event_color
+
+      # Resolve time scheme if provided
+      if time_scheme
+        time_scheme_id = resolve_time_scheme_id(time_scheme)
+        if time_scheme_id
+          update_data[:timeSchemeId] = time_scheme_id
+        else
+          raise InvalidRecordError, "Time scheme '#{time_scheme}' not found"
+        end
+      end
+
+      raise InvalidRecordError, 'No update fields provided' if update_data.empty?
+
+      response = make_request(:patch, "/tasks/#{task_id}", update_data)
+      Task.new(response)
+    rescue ApiError => e
+      raise NotFoundError, "Task #{task_id} not found" if e.status_code == 404
+
+      raise
+    end
+
+    # Mark a task as complete
+    def complete_task(task_id)
+      # Use PATCH to update status to ARCHIVED to match Reclaim app behavior
+      response = make_request(:patch, "/tasks/#{task_id}", { status: 'ARCHIVED' })
+      Task.new(response)
+    rescue ApiError => e
+      raise NotFoundError, "Task #{task_id} not found" if e.status_code == 404
+
+      raise
+    end
+
+    # Delete a task
+    def delete_task(task_id)
+      make_request(:delete, "/tasks/#{task_id}")
+      true
+    rescue ApiError => e
+      raise NotFoundError, "Task #{task_id} not found" if e.status_code == 404
+
+      raise
+    end
+
+    # List all available time schemes
+    def list_time_schemes
+      get_time_schemes
+    end
+
+    # Get formatted list of time schemes for display
+    def format_time_schemes
+      schemes = list_time_schemes
+      return "No time schemes found." if schemes.empty?
+
+      output = "\nAvailable Time Schemes:\n"
+      output += "-" * 50 + "\n"
+
+      schemes.each do |scheme|
+        title = scheme['title'] || 'Untitled'
+        scheme_id = scheme['id'] || 'N/A'
+        policy_type = scheme['policyType'] || 'N/A'
+
+        output += "• #{title}\n"
+        output += "  ID: #{scheme_id}\n"
+        output += "  Type: #{policy_type}\n\n"
+      end
+
+      output += "Usage: time_scheme: \"Work Hours\" or time_scheme: \"work\"\n"
+      output
+    end
+
+    private
+
+    # Make HTTP request to Reclaim API
+    def make_request(method, endpoint, data = nil)
+      uri = URI("#{BASE_URL}#{endpoint}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      # Configure certificate store without CRL checking (OpenSSL 3.x compatibility)
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      http.cert_store = store
+
+      request_class = case method
+                      when :get then Net::HTTP::Get
+                      when :post then Net::HTTP::Post
+                      when :patch then Net::HTTP::Patch
+                      when :put then Net::HTTP::Put
+                      when :delete then Net::HTTP::Delete
+                      else
+                        raise ArgumentError, "Unsupported HTTP method: #{method}"
+                      end
+
+      request = request_class.new(uri)
+      request['Authorization'] = "Bearer #{@token}"
+      request['Content-Type'] = 'application/json'
+      request['User-Agent'] = 'Reclaim Ruby Client/1.0'
+
+      if data && [:post, :patch, :put].include?(method)
+        request.body = data.to_json
+      end
+
+      response = http.request(request)
+
+      case response.code.to_i
+      when 200..299
+        return true if response.body.nil? || response.body.strip.empty?
+
+        JSON.parse(response.body)
+      when 401
+        raise AuthenticationError, 'Invalid or expired API token'
+      when 404
+        raise ApiError.new('Resource not found', 404, response.body)
+      when 422
+        error_msg = 'Validation error'
+        if response.body
+          begin
+            error_data = JSON.parse(response.body)
+            error_msg = error_data['message'] || error_data['error'] || error_msg
+          rescue JSON::ParserError
+            # Use default message if JSON parsing fails
+          end
+        end
+        raise InvalidRecordError, error_msg
+      else
+        error_msg = "HTTP #{response.code}: #{response.message}"
+        raise ApiError.new(error_msg, response.code.to_i, response.body)
+      end
+    rescue JSON::ParserError => e
+      raise ApiError, "Invalid JSON response: #{e.message}"
+    rescue StandardError => e
+      raise ApiError, "Network error: #{e.message}"
+    end
+
+    # Get time schemes with caching
+    def get_time_schemes
+      return @time_schemes_cache if @time_schemes_cache
+
+      response = make_request(:get, '/timeschemes')
+      @time_schemes_cache = response || []
+    rescue StandardError => e
+      warn "Error fetching time schemes: #{e.message}"
+      []
+    end
+
+    # Resolve time scheme name to ID with fuzzy matching
+    def resolve_time_scheme_id(name_or_id)
+      return nil unless name_or_id
+
+      name_or_id = name_or_id.to_s
+
+      # If it looks like a UUID, return as-is
+      if name_or_id.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
+        return name_or_id
+      end
+
+      schemes = get_time_schemes
+      return nil if schemes.empty?
+
+      name_lower = name_or_id.downcase
+
+      # Common aliases for quick matching
+      aliases = {
+        'work' => ['work', 'work hours', 'working hours', 'business hours'],
+        'personal' => ['personal', 'personal hours', 'off hours', 'off-hours', 'private']
+      }
+
+      # Check aliases first
+      aliases.each do |alias_key, alias_list|
+        if alias_list.include?(name_lower)
+          # Find scheme that contains the alias key in its title
+          scheme = schemes.find do |s|
+            s['title']&.downcase&.include?(alias_key)
+          end
+          return scheme['id'] if scheme
+        end
+      end
+
+      # Direct title matching (exact, case-insensitive)
+      scheme = schemes.find { |s| s['title']&.downcase == name_lower }
+      return scheme['id'] if scheme
+
+      # Partial matching (contains)
+      scheme = schemes.find { |s| s['title']&.downcase&.include?(name_lower) }
+      return scheme['id'] if scheme
+
+      nil
+    end
+  end
+end

data/lib/reclaim/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Reclaim
+  # Base exception class for all Reclaim-related errors
+  class Error < StandardError; end
+
+  # Authentication-related errors
+  class AuthenticationError < Error; end
+
+  # API-related errors (network issues, invalid responses, etc.)
+  class ApiError < Error
+    attr_reader :status_code, :response_body
+
+    def initialize(message, status_code = nil, response_body = nil)
+      super(message)
+      @status_code = status_code
+      @response_body = response_body
+    end
+  end
+
+  # Resource not found errors
+  class NotFoundError < Error; end
+
+  # Invalid record/validation errors
+  class InvalidRecordError < Error; end
+end