brand.dev 0.1.0.pre.alpha.8 → 0.1.0.pre.alpha.9

data/lib/brand_dev/models.rb

@@ -51,5 +51,11 @@ module BrandDev
 
   BrandRetrieveParams = BrandDev::Models::BrandRetrieveParams
 
+  BrandRetrieveSimplifiedParams = BrandDev::Models::BrandRetrieveSimplifiedParams
+
+  BrandScreenshotParams = BrandDev::Models::BrandScreenshotParams
+
   BrandSearchParams = BrandDev::Models::BrandSearchParams
+
+  BrandStyleguideParams = BrandDev::Models::BrandStyleguideParams
 end

data/lib/brand_dev/resources/brand.rb

@@ -179,6 +179,64 @@ module BrandDev
         )
       end
 
+      # Some parameter documentations has been truncated, see
+      # {BrandDev::Models::BrandRetrieveSimplifiedParams} for more details.
+      #
+      # 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.
+      #
+      # @overload retrieve_simplified(domain:, timeout_ms: nil, request_options: {})
+      #
+      # @param domain [String] Domain name to retrieve simplified brand data for
+      #
+      # @param timeout_ms [Integer] Optional timeout in milliseconds for the request. If the request takes longer th
+      #
+      # @param request_options [BrandDev::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [BrandDev::Models::BrandRetrieveSimplifiedResponse]
+      #
+      # @see BrandDev::Models::BrandRetrieveSimplifiedParams
+      def retrieve_simplified(params)
+        parsed, options = BrandDev::BrandRetrieveSimplifiedParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "brand/retrieve-simplified",
+          query: parsed.transform_keys(timeout_ms: "timeoutMS"),
+          model: BrandDev::Models::BrandRetrieveSimplifiedResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {BrandDev::Models::BrandScreenshotParams} for more details.
+      #
+      # Beta feature: Capture a screenshot of a website. Supports both viewport
+      # (standard browser view) and full-page screenshots. Returns a URL to the uploaded
+      # screenshot image hosted on our CDN.
+      #
+      # @overload screenshot(domain:, full_screenshot: nil, request_options: {})
+      #
+      # @param domain [String] Domain name to take screenshot of (e.g., 'example.com', 'google.com'). The domai
+      #
+      # @param full_screenshot [Symbol, BrandDev::Models::BrandScreenshotParams::FullScreenshot] Optional parameter to determine screenshot type. If 'true', takes a full page sc
+      #
+      # @param request_options [BrandDev::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [BrandDev::Models::BrandScreenshotResponse]
+      #
+      # @see BrandDev::Models::BrandScreenshotParams
+      def screenshot(params)
+        parsed, options = BrandDev::BrandScreenshotParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "brand/screenshot",
+          query: parsed.transform_keys(full_screenshot: "fullScreenshot"),
+          model: BrandDev::Models::BrandScreenshotResponse,
+          options: options
+        )
+      end
+
       # Some parameter documentations has been truncated, see
       # {BrandDev::Models::BrandSearchParams} for more details.
       #
@@ -206,6 +264,36 @@ module BrandDev
         )
       end
 
+      # Some parameter documentations has been truncated, see
+      # {BrandDev::Models::BrandStyleguideParams} for more details.
+      #
+      # Beta feature: Automatically extract comprehensive design system information from
+      # a brand's website including colors, typography, spacing, shadows, and UI
+      # components. Uses AI-powered analysis of website screenshots to identify design
+      # patterns and create a reusable styleguide.
+      #
+      # @overload styleguide(domain:, timeout_ms: nil, request_options: {})
+      #
+      # @param domain [String] Domain name to extract styleguide from (e.g., 'example.com', 'google.com'). The
+      #
+      # @param timeout_ms [Integer] Optional timeout in milliseconds for the request. If the request takes longer th
+      #
+      # @param request_options [BrandDev::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [BrandDev::Models::BrandStyleguideResponse]
+      #
+      # @see BrandDev::Models::BrandStyleguideParams
+      def styleguide(params)
+        parsed, options = BrandDev::BrandStyleguideParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "brand/styleguide",
+          query: parsed.transform_keys(timeout_ms: "timeoutMS"),
+          model: BrandDev::Models::BrandStyleguideResponse,
+          options: options
+        )
+      end
+
       # @api private
       #
       # @param client [BrandDev::Client]

data/lib/brand_dev/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BrandDev
-  VERSION = "0.1.0.pre.alpha.8"
+  VERSION = "0.1.0.pre.alpha.9"
 end

data/lib/brand_dev.rb

@@ -62,7 +62,13 @@ require_relative "brand_dev/models/brand_retrieve_naics_params"
 require_relative "brand_dev/models/brand_retrieve_naics_response"
 require_relative "brand_dev/models/brand_retrieve_params"
 require_relative "brand_dev/models/brand_retrieve_response"
+require_relative "brand_dev/models/brand_retrieve_simplified_params"
+require_relative "brand_dev/models/brand_retrieve_simplified_response"
+require_relative "brand_dev/models/brand_screenshot_params"
+require_relative "brand_dev/models/brand_screenshot_response"
 require_relative "brand_dev/models/brand_search_params"
 require_relative "brand_dev/models/brand_search_response"
+require_relative "brand_dev/models/brand_styleguide_params"
+require_relative "brand_dev/models/brand_styleguide_response"
 require_relative "brand_dev/models"
 require_relative "brand_dev/resources/brand"

data/rbi/brand_dev/errors.rbi

@@ -8,6 +8,22 @@ module BrandDev
     end
 
     class ConversionError < BrandDev::Errors::Error
+      sig { returns(T.nilable(StandardError)) }
+      def cause
+      end
+
+      # @api private
+      sig do
+        params(
+          on: T::Class[StandardError],
+          method: Symbol,
+          target: T.anything,
+          value: T.anything,
+          cause: T.nilable(StandardError)
+        ).returns(T.attached_class)
+      end
+      def self.new(on:, method:, target:, value:, cause: nil)
+      end
     end
 
     class APIError < BrandDev::Errors::Error

data/rbi/brand_dev/internal/type/boolean.rbi

@@ -22,6 +22,8 @@ module BrandDev
 
         class << self
           # @api private
+          #
+          # Coerce value to Boolean if possible, otherwise return the original value.
           sig do
             override
               .params(

data/rbi/brand_dev/internal/type/converter.rbi

@@ -15,12 +15,14 @@ module BrandDev
         CoerceState =
           T.type_alias do
             {
-              strictness: T.any(T::Boolean, Symbol),
+              translate_names: T::Boolean,
+              strictness: T::Boolean,
               exactness: {
                 yes: Integer,
                 no: Integer,
                 maybe: Integer
               },
+              error: T::Class[StandardError],
               branched: Integer
             }
           end
@@ -88,6 +90,15 @@ module BrandDev
           def self.type_info(spec)
           end
 
+          # @api private
+          sig do
+            params(translate_names: T::Boolean).returns(
+              BrandDev::Internal::Type::Converter::CoerceState
+            )
+          end
+          def self.new_coerce_state(translate_names: true)
+          end
+
           # @api private
           #
           # Based on `target`, transform `value` into `target`, to the extent possible:
@@ -109,14 +120,11 @@ module BrandDev
           def self.coerce(
             target,
             value,
-            # The `strictness` is one of `true`, `false`, or `:strong`. This informs the
-            # coercion strategy when we have to decide between multiple possible conversion
-            # targets:
+            # The `strictness` is one of `true`, `false`. This informs the coercion strategy
+            # when we have to decide between multiple possible conversion targets:
             #
             # - `true`: the conversion must be exact, with minimum coercion.
             # - `false`: the conversion can be approximate, with some coercion.
-            # - `:strong`: the conversion must be exact, with no coercion, and raise an error
-            #   if not possible.
             #
             # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
             # any given conversion attempt, the exactness will be updated based on how closely
@@ -128,15 +136,7 @@ module BrandDev
             # - `no`: the value cannot be converted to the target type.
             #
             # See implementation below for more details.
-            state: {
-              strictness: true,
-              exactness: {
-                yes: 0,
-                no: 0,
-                maybe: 0
-              },
-              branched: 0
-            }
+            state: BrandDev::Internal::Type::Converter.new_coerce_state
           )
           end
 

data/rbi/brand_dev/internal/type/union.rbi

@@ -78,6 +78,11 @@ module BrandDev
         end
 
         # @api private
+        #
+        # Tries to efficiently coerce the given value to one of the known variants.
+        #
+        # If the value cannot match any of the known variants, the coercion is considered
+        # non-viable and returns the original value.
         sig do
           override
             .params(

data/rbi/brand_dev/internal/type/unknown.rbi

@@ -22,6 +22,8 @@ module BrandDev
 
         class << self
           # @api private
+          #
+          # No coercion needed for Unknown type.
           sig do
             override
               .params(

data/rbi/brand_dev/models/brand_retrieve_simplified_params.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module BrandDev
+  module Models
+    class BrandRetrieveSimplifiedParams < BrandDev::Internal::Type::BaseModel
+      extend BrandDev::Internal::Type::RequestParameters::Converter
+      include BrandDev::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            BrandDev::BrandRetrieveSimplifiedParams,
+            BrandDev::Internal::AnyHash
+          )
+        end
+
+      # Domain name to retrieve simplified brand data for
+      sig { returns(String) }
+      attr_accessor :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).
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :timeout_ms
+
+      sig { params(timeout_ms: Integer).void }
+      attr_writer :timeout_ms
+
+      sig do
+        params(
+          domain: String,
+          timeout_ms: Integer,
+          request_options: BrandDev::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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
+
+      sig do
+        override.returns(
+          {
+            domain: String,
+            timeout_ms: Integer,
+            request_options: BrandDev::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end