context.dev 0.0.2

data/rbi/context_dev/resources/brand.rbi

@@ -0,0 +1,545 @@
+# typed: strong
+
+module ContextDev
+  module Resources
+    class Brand
+      # Retrieve logos, backdrops, colors, industry, description, and more from any
+      # domain
+      sig do
+        params(
+          domain: String,
+          force_language:
+            ContextDev::BrandRetrieveParams::ForceLanguage::OrSymbol,
+          max_speed: T::Boolean,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveResponse)
+      end
+      def retrieve(
+        # Domain name to retrieve brand data for (e.g., 'example.com', 'google.com').
+        # Cannot be used with name or ticker parameters.
+        domain:,
+        # Optional parameter to force the language of the retrieved brand data. Works with
+        # all three lookup methods.
+        force_language: nil,
+        # Optional parameter to optimize the API call for maximum speed. When set to true,
+        # the API will skip time-consuming operations for faster response at the cost of
+        # less comprehensive data. Works with all three lookup methods.
+        max_speed: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Beta feature: Given a single URL, determines if it is a product detail page,
+      # classifies the platform/product type, and extracts the product information.
+      # Supports Amazon, TikTok Shop, Etsy, and generic ecommerce sites.
+      sig do
+        params(
+          url: String,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandAIProductResponse)
+      end
+      def ai_product(
+        # The product page URL to extract product data from.
+        url:,
+        # Optional timeout in milliseconds for the request. Maximum allowed value is
+        # 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Beta feature: Extract product information from a brand's website. Brand.dev will
+      # analyze the website and return a list of products with details such as name,
+      # description, image, pricing, features, and more.
+      sig do
+        params(
+          body:
+            T.any(
+              ContextDev::BrandAIProductsParams::Body::ByDomain::OrHash,
+              ContextDev::BrandAIProductsParams::Body::ByDirectURL::OrHash
+            ),
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandAIProductsResponse)
+      end
+      def ai_products(body:, request_options: {})
+      end
+
+      # Use AI to extract specific data points from a brand's website. The AI will crawl
+      # the website and extract the requested information based on the provided data
+      # points.
+      sig do
+        params(
+          data_to_extract:
+            T::Array[ContextDev::BrandAIQueryParams::DataToExtract::OrHash],
+          domain: String,
+          specific_pages: ContextDev::BrandAIQueryParams::SpecificPages::OrHash,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandAIQueryResponse)
+      end
+      def ai_query(
+        # Array of data points to extract from the website
+        data_to_extract:,
+        # The domain name to analyze
+        domain:,
+        # Optional object specifying which pages to analyze
+        specific_pages: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Extract font information from a brand's website including font families, usage
+      # statistics, fallbacks, and element/word counts.
+      sig do
+        params(
+          domain: String,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandFontsResponse)
+      end
+      def fonts(
+        # Domain name to extract fonts from (e.g., 'example.com', 'google.com'). The
+        # domain will be automatically normalized and validated.
+        domain:,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Endpoint specially designed for platforms that want to identify transaction data
+      # by the transaction title.
+      sig do
+        params(
+          transaction_info: String,
+          city: String,
+          country_gl:
+            ContextDev::BrandIdentifyFromTransactionParams::CountryGl::OrSymbol,
+          force_language:
+            ContextDev::BrandIdentifyFromTransactionParams::ForceLanguage::OrSymbol,
+          high_confidence_only: T::Boolean,
+          max_speed: T::Boolean,
+          mcc: String,
+          phone: Float,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandIdentifyFromTransactionResponse)
+      end
+      def identify_from_transaction(
+        # Transaction information to identify the brand
+        transaction_info:,
+        # Optional city name to prioritize when searching for the brand.
+        city: nil,
+        # Optional country code (GL parameter) to specify the country. This affects the
+        # geographic location used for search queries.
+        country_gl: nil,
+        # Optional parameter to force the language of the retrieved brand data.
+        force_language: nil,
+        # When set to true, the API will perform an additional verification steps to
+        # ensure the identified brand matches the transaction with high confidence.
+        # Defaults to false.
+        high_confidence_only: nil,
+        # Optional parameter to optimize the API call for maximum speed. When set to true,
+        # the API will skip time-consuming operations for faster response at the cost of
+        # less comprehensive data.
+        max_speed: nil,
+        # Optional Merchant Category Code (MCC) to help identify the business
+        # category/industry.
+        mcc: nil,
+        # Optional phone number from the transaction to help verify brand match.
+        phone: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Signal that you may fetch brand data for a particular domain soon to improve
+      # latency. This endpoint does not charge credits and is available for paid
+      # customers to optimize future requests. [You must be on a paid plan to use this
+      # endpoint]
+      sig do
+        params(
+          domain: String,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandPrefetchResponse)
+      end
+      def prefetch(
+        # Domain name to prefetch brand data for
+        domain:,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Signal that you may fetch brand data for a particular domain soon to improve
+      # latency. This endpoint accepts an email address, extracts the domain from it,
+      # validates that it's not a disposable or free email provider, and queues the
+      # domain for prefetching. This endpoint does not charge credits and is available
+      # for paid customers to optimize future requests. [You must be on a paid plan to
+      # use this endpoint]
+      sig do
+        params(
+          email: String,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandPrefetchByEmailResponse)
+      end
+      def prefetch_by_email(
+        # Email address to prefetch brand data for. The domain will be extracted from the
+        # email. Free email providers (gmail.com, yahoo.com, etc.) and disposable email
+        # addresses are not allowed.
+        email:,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve brand information using an email address while detecting disposable and
+      # free email addresses. This endpoint extracts the domain from the email address
+      # and returns brand data for that domain. Disposable and free email addresses
+      # (like gmail.com, yahoo.com) will throw a 422 error.
+      sig do
+        params(
+          email: String,
+          force_language:
+            ContextDev::BrandRetrieveByEmailParams::ForceLanguage::OrSymbol,
+          max_speed: T::Boolean,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveByEmailResponse)
+      end
+      def retrieve_by_email(
+        # Email address to retrieve brand data for (e.g., 'contact@example.com'). The
+        # domain will be extracted from the email. Free email providers (gmail.com,
+        # yahoo.com, etc.) and disposable email addresses are not allowed.
+        email:,
+        # Optional parameter to force the language of the retrieved brand data.
+        force_language: nil,
+        # Optional parameter to optimize the API call for maximum speed. When set to true,
+        # the API will skip time-consuming operations for faster response at the cost of
+        # less comprehensive data.
+        max_speed: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve brand information using an ISIN (International Securities
+      # Identification Number). This endpoint looks up the company associated with the
+      # ISIN and returns its brand data.
+      sig do
+        params(
+          isin: String,
+          force_language:
+            ContextDev::BrandRetrieveByIsinParams::ForceLanguage::OrSymbol,
+          max_speed: T::Boolean,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveByIsinResponse)
+      end
+      def retrieve_by_isin(
+        # ISIN (International Securities Identification Number) to retrieve brand data for
+        # (e.g., 'AU000000IMD5', 'US0378331005'). Must be exactly 12 characters: 2 letters
+        # followed by 9 alphanumeric characters and ending with a digit.
+        isin:,
+        # Optional parameter to force the language of the retrieved brand data.
+        force_language: nil,
+        # Optional parameter to optimize the API call for maximum speed. When set to true,
+        # the API will skip time-consuming operations for faster response at the cost of
+        # less comprehensive data.
+        max_speed: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve brand information using a company name. This endpoint searches for the
+      # company by name and returns its brand data.
+      sig do
+        params(
+          name: String,
+          force_language:
+            ContextDev::BrandRetrieveByNameParams::ForceLanguage::OrSymbol,
+          max_speed: T::Boolean,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveByNameResponse)
+      end
+      def retrieve_by_name(
+        # Company name to retrieve brand data for (e.g., 'Apple Inc', 'Microsoft
+        # Corporation'). Must be 3-30 characters.
+        name:,
+        # Optional parameter to force the language of the retrieved brand data.
+        force_language: nil,
+        # Optional parameter to optimize the API call for maximum speed. When set to true,
+        # the API will skip time-consuming operations for faster response at the cost of
+        # less comprehensive data.
+        max_speed: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve brand information using a stock ticker symbol. This endpoint looks up
+      # the company associated with the ticker and returns its brand data.
+      sig do
+        params(
+          ticker: String,
+          force_language:
+            ContextDev::BrandRetrieveByTickerParams::ForceLanguage::OrSymbol,
+          max_speed: T::Boolean,
+          ticker_exchange:
+            ContextDev::BrandRetrieveByTickerParams::TickerExchange::OrSymbol,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveByTickerResponse)
+      end
+      def retrieve_by_ticker(
+        # Stock ticker symbol to retrieve brand data for (e.g., 'AAPL', 'GOOGL', 'BRK.A').
+        # Must be 1-15 characters, letters/numbers/dots only.
+        ticker:,
+        # Optional parameter to force the language of the retrieved brand data.
+        force_language: nil,
+        # Optional parameter to optimize the API call for maximum speed. When set to true,
+        # the API will skip time-consuming operations for faster response at the cost of
+        # less comprehensive data.
+        max_speed: nil,
+        # Optional stock exchange for the ticker. Defaults to NASDAQ if not specified.
+        ticker_exchange: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Endpoint to classify any brand into a 2022 NAICS code.
+      sig do
+        params(
+          input: String,
+          max_results: Integer,
+          min_results: Integer,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveNaicsResponse)
+      end
+      def retrieve_naics(
+        # Brand domain or title to retrieve NAICS code for. If a valid domain is provided
+        # in `input`, it will be used for classification, otherwise, we will search for
+        # the brand using the provided title.
+        input:,
+        # Maximum number of NAICS codes to return. Must be between 1 and 10. Defaults
+        # to 5.
+        max_results: nil,
+        # Minimum number of NAICS codes to return. Must be at least 1. Defaults to 1.
+        min_results: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns a simplified version of brand data containing only essential
+      # information: domain, title, colors, logos, and backdrops. This endpoint is
+      # optimized for faster responses and reduced data transfer.
+      sig do
+        params(
+          domain: String,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandRetrieveSimplifiedResponse)
+      end
+      def retrieve_simplified(
+        # Domain name to retrieve simplified brand data for
+        domain:,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Capture a screenshot of a website. Supports both viewport (standard browser
+      # view) and full-page screenshots. Can also screenshot specific page types (login,
+      # pricing, etc.) by using heuristics to find the appropriate URL. Returns a URL to
+      # the uploaded screenshot image hosted on our CDN.
+      sig do
+        params(
+          domain: String,
+          full_screenshot:
+            ContextDev::BrandScreenshotParams::FullScreenshot::OrSymbol,
+          page: ContextDev::BrandScreenshotParams::Page::OrSymbol,
+          prioritize: ContextDev::BrandScreenshotParams::Prioritize::OrSymbol,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandScreenshotResponse)
+      end
+      def screenshot(
+        # Domain name to take screenshot of (e.g., 'example.com', 'google.com'). The
+        # domain will be automatically normalized and validated.
+        domain:,
+        # Optional parameter to determine screenshot type. If 'true', takes a full page
+        # screenshot capturing all content. If 'false' or not provided, takes a viewport
+        # screenshot (standard browser view).
+        full_screenshot: nil,
+        # Optional parameter to specify which page type to screenshot. If provided, the
+        # system will scrape the domain's links and use heuristics to find the most
+        # appropriate URL for the specified page type (30 supported languages). If not
+        # provided, screenshots the main domain landing page.
+        page: nil,
+        # Optional parameter to prioritize screenshot capture. If 'speed', optimizes for
+        # faster capture with basic quality. If 'quality', optimizes for higher quality
+        # with longer wait times. Defaults to 'quality' if not provided.
+        prioritize: nil,
+        request_options: {}
+      )
+      end
+
+      # Automatically extract comprehensive design system information from a brand's
+      # website including colors, typography, spacing, shadows, and UI components.
+      # Either 'domain' or 'directUrl' must be provided as a query parameter, but not
+      # both.
+      sig do
+        params(
+          direct_url: String,
+          domain: String,
+          prioritize: ContextDev::BrandStyleguideParams::Prioritize::OrSymbol,
+          timeout_ms: Integer,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandStyleguideResponse)
+      end
+      def styleguide(
+        # A specific URL to fetch the styleguide from directly, bypassing domain
+        # resolution (e.g., 'https://example.com/design-system').
+        direct_url: nil,
+        # Domain name to extract styleguide from (e.g., 'example.com', 'google.com'). The
+        # domain will be automatically normalized and validated.
+        domain: nil,
+        # Optional parameter to prioritize screenshot capture for styleguide extraction.
+        # If 'speed', optimizes for faster capture with basic quality. If 'quality',
+        # optimizes for higher quality with longer wait times. Defaults to 'quality' if
+        # not provided.
+        prioritize: nil,
+        # Optional timeout in milliseconds for the request. If the request takes longer
+        # than this value, it will be aborted with a 408 status code. Maximum allowed
+        # value is 300000ms (5 minutes).
+        timeout_ms: nil,
+        request_options: {}
+      )
+      end
+
+      # Scrapes the given URL and returns the raw HTML content of the page. Uses
+      # automatic proxy escalation to handle blocked sites.
+      sig do
+        params(
+          url: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandWebScrapeHTMLResponse)
+      end
+      def web_scrape_html(
+        # Full URL to scrape (must include http:// or https:// protocol)
+        url:,
+        request_options: {}
+      )
+      end
+
+      # Scrapes all images from the given URL. Extracts images from img, svg,
+      # picture/source, link, and video elements including inline SVGs, base64 data
+      # URIs, and standard URLs.
+      sig do
+        params(
+          url: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandWebScrapeImagesResponse)
+      end
+      def web_scrape_images(
+        # Full URL to scrape images from (must include http:// or https:// protocol)
+        url:,
+        request_options: {}
+      )
+      end
+
+      # Scrapes the given URL, converts the HTML content to GitHub Flavored Markdown
+      # (GFM), and returns the result. Uses automatic proxy escalation to handle blocked
+      # sites.
+      sig do
+        params(
+          url: String,
+          include_images: T::Boolean,
+          include_links: T::Boolean,
+          shorten_base64_images: T::Boolean,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandWebScrapeMdResponse)
+      end
+      def web_scrape_md(
+        # Full URL to scrape and convert to markdown (must include http:// or https://
+        # protocol)
+        url:,
+        # Include image references in Markdown output
+        include_images: nil,
+        # Preserve hyperlinks in Markdown output
+        include_links: nil,
+        # Shorten base64-encoded image data in the Markdown output
+        shorten_base64_images: nil,
+        request_options: {}
+      )
+      end
+
+      # Crawls the sitemap of the given domain and returns all discovered page URLs.
+      # Supports sitemap index files (recursive), parallel fetching with concurrency
+      # control, deduplication, and filters out non-page resources (images, PDFs, etc.).
+      sig do
+        params(
+          domain: String,
+          request_options: ContextDev::RequestOptions::OrHash
+        ).returns(ContextDev::Models::BrandWebScrapeSitemapResponse)
+      end
+      def web_scrape_sitemap(
+        # Domain name to crawl sitemaps for (e.g., 'example.com'). The domain will be
+        # automatically normalized and validated.
+        domain:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: ContextDev::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/context_dev/version.rbi

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

data/sig/context_dev/client.rbs

@@ -0,0 +1,26 @@
+module ContextDev
+  class Client < ContextDev::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 brand: ContextDev::Resources::Brand
+
+    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

data/sig/context_dev/errors.rbs

@@ -0,0 +1,117 @@
+module ContextDev
+  module Errors
+    class Error < StandardError
+      attr_accessor cause: StandardError?
+    end
+
+    class ConversionError < ContextDev::Errors::Error
+      def cause: -> StandardError?
+
+      def initialize: (
+        on: Class,
+        method: Symbol,
+        target: top,
+        value: top,
+        ?cause: StandardError?
+      ) -> void
+    end
+
+    class APIError < ContextDev::Errors::Error
+      attr_accessor url: URI::Generic
+
+      attr_accessor status: Integer?
+
+      attr_accessor headers: ::Hash[String, String]?
+
+      attr_accessor body: top?
+
+      def initialize: (
+        url: URI::Generic,
+        ?status: Integer?,
+        ?headers: ::Hash[String, String]?,
+        ?body: Object?,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIConnectionError < ContextDev::Errors::APIError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APITimeoutError < ContextDev::Errors::APIConnectionError
+      def initialize: (
+        url: URI::Generic,
+        ?status: nil,
+        ?headers: ::Hash[String, String]?,
+        ?body: nil,
+        ?request: nil,
+        ?response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class APIStatusError < ContextDev::Errors::APIError
+      def self.for: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> instance
+
+      def initialize: (
+        url: URI::Generic,
+        status: Integer,
+        headers: ::Hash[String, String]?,
+        body: Object?,
+        request: nil,
+        response: nil,
+        ?message: String?
+      ) -> void
+    end
+
+    class BadRequestError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 400
+    end
+
+    class AuthenticationError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 401
+    end
+
+    class PermissionDeniedError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 403
+    end
+
+    class NotFoundError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 404
+    end
+
+    class ConflictError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 409
+    end
+
+    class UnprocessableEntityError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 422
+    end
+
+    class RateLimitError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: 429
+    end
+
+    class InternalServerError < ContextDev::Errors::APIStatusError
+      HTTP_STATUS: Range[Integer]
+    end
+  end
+end