moov_ruby 0.0.0.pre.dev.23 → 0.0.0.pre.dev.24

data/lib/moov/models/operations.rb

@@ -66,6 +66,9 @@ module Moov
       autoload :CreateWalletRequest, 'moov/models/operations/createwallet_request.rb'
       autoload :CreateWalletResponse, 'moov/models/operations/createwallet_response.rb'
       autoload :CreateWebhookResponse, 'moov/models/operations/createwebhook_response.rb'
+      autoload :DeleteAvatarSecurity, 'moov/models/operations/deleteavatar_security.rb'
+      autoload :DeleteAvatarRequest, 'moov/models/operations/deleteavatar_request.rb'
+      autoload :DeleteAvatarResponse, 'moov/models/operations/deleteavatar_response.rb'
       autoload :DeleteDisputeEvidenceFileRequest, 'moov/models/operations/deletedisputeevidencefile_request.rb'
       autoload :DeleteDisputeEvidenceFileResponse, 'moov/models/operations/deletedisputeevidencefile_response.rb'
       autoload :DeleteImageRequest, 'moov/models/operations/deleteimage_request.rb'
@@ -270,6 +273,7 @@ module Moov
       autoload :ListPaymentLinksResponse, 'moov/models/operations/listpaymentlinks_response.rb'
       autoload :ListPaymentMethodsRequest, 'moov/models/operations/listpaymentmethods_request.rb'
       autoload :ListPaymentMethodsResponse, 'moov/models/operations/listpaymentmethods_response.rb'
+      autoload :ListProductCategoriesResponse, 'moov/models/operations/listproductcategories_response.rb'
       autoload :ListProductsRequest, 'moov/models/operations/listproducts_request.rb'
       autoload :ListProductsResponse, 'moov/models/operations/listproducts_response.rb'
       autoload :ListReceiptsRequest, 'moov/models/operations/listreceipts_request.rb'
@@ -362,6 +366,9 @@ module Moov
       autoload :UpdateWalletResponse, 'moov/models/operations/updatewallet_response.rb'
       autoload :UpdateWebhookRequest, 'moov/models/operations/updatewebhook_request.rb'
       autoload :UpdateWebhookResponse, 'moov/models/operations/updatewebhook_response.rb'
+      autoload :UploadAvatarSecurity, 'moov/models/operations/uploadavatar_security.rb'
+      autoload :UploadAvatarRequest, 'moov/models/operations/uploadavatar_request.rb'
+      autoload :UploadAvatarResponse, 'moov/models/operations/uploadavatar_response.rb'
       autoload :UploadDisputeEvidenceFileRequest, 'moov/models/operations/uploaddisputeevidencefile_request.rb'
       autoload :UploadDisputeEvidenceFileResponse, 'moov/models/operations/uploaddisputeevidencefile_response.rb'
       autoload :UploadDisputeEvidenceTextRequest, 'moov/models/operations/uploaddisputeevidencetext_request.rb'

data/lib/moov/products.rb

@@ -41,15 +41,9 @@ module Moov
 
 
 
-    sig { params(account_id: ::String, title: T.nilable(::String), skip: T.nilable(::Integer), count: T.nilable(::Integer), timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ListProductsResponse) }
-    def list(account_id:, title: nil, skip: nil, count: nil, timeout_ms: nil, http_headers: nil)
+    sig { params(request: Models::Operations::ListProductsRequest, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ListProductsResponse) }
+    def list(request:, timeout_ms: nil, http_headers: nil)
       # list - List active (non-disabled) products for an account.
-      request = Models::Operations::ListProductsRequest.new(
-        account_id: account_id,
-        title: title,
-        skip: skip,
-        count: count
-      )
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
@@ -736,5 +730,116 @@ module Moov
 
       end
     end
+
+
+    sig { params(timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::ListProductCategoriesResponse) }
+    def list_categories(timeout_ms: nil, http_headers: nil)
+      # list_categories - Returns the full, read-only list of product categories from the product taxonomy.
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/product-categories"
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'listProductCategories',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+
+      begin
+        http_response = T.must(connection).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::ProductCategories)
+          response = Models::Operations::ListProductCategoriesResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: http_response.headers,
+            product_categories: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['401', '403', '429'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['500', '504'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::Moov::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
 end
 end

data/lib/moov/sdk_hooks/clientcredentials.rb

@@ -0,0 +1,386 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'net/http'
+require 'uri'
+
+require_relative './types'
+
+module Moov
+  module SDKHooks
+    class Credentials
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :client_id
+
+      sig { returns(String) }
+      attr_reader :client_secret
+
+      sig { returns(String) }
+      attr_reader :token_url
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :scopes
+
+      sig { returns(T::Hash[String, String]) }
+      attr_reader :additional_properties
+
+      sig do
+        params(
+          client_id: String,
+          client_secret: String,
+          token_url: String,
+          scopes: T.nilable(T::Array[String]),
+          additional_properties: T::Hash[String, String]
+        ).void
+      end
+      def initialize(client_id:, client_secret:, token_url:, scopes: nil, additional_properties: {})
+        @client_id = client_id
+        @client_secret = client_secret
+        @token_url = token_url
+        @scopes = scopes
+        @additional_properties = additional_properties
+      end
+    end
+
+    class Session
+      extend T::Sig
+
+      sig { returns(Credentials) }
+      attr_reader :credentials
+
+      sig { returns(String) }
+      attr_reader :token
+
+      sig { returns(T::Array[String]) }
+      attr_reader :scopes
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :expires_at
+
+      sig do
+        params(
+          credentials: Credentials,
+          token: String,
+          scopes: T::Array[String],
+          expires_at: T.nilable(Integer)
+        ).void
+      end
+      def initialize(credentials:, token:, scopes:, expires_at: nil)
+        @credentials = credentials
+        @token = token
+        @scopes = scopes
+        @expires_at = expires_at
+      end
+    end
+
+    class ClientCredentialsHook < AbstractSDKHook
+
+      extend T::Sig
+
+      @global_lock = Mutex.new
+      @client_locks = {}
+      @sessions = {}
+
+      class << self
+        attr_reader :global_lock
+        attr_accessor :client_locks, :sessions
+      end
+
+      sig { override.params(config: SDKConfiguration).returns(SDKConfiguration) }
+      def sdk_init(config:)
+        raise 'Client is required' if config.client.nil?
+
+        @client = config.client
+        config
+      end
+
+      sig do
+        override.params(
+          hook_ctx: BeforeRequestHookContext,
+          request: Faraday::Request
+        ).returns(Faraday::Request)
+      end
+      def before_request(hook_ctx:, request:)
+        return request if hook_disabled?(hook_ctx)
+
+        credentials = get_credentials(hook_ctx)
+        return request if credentials.nil?
+
+        session_key = get_session_key(credentials.client_id, credentials.client_secret)
+        scopes = get_required_scopes(credentials, hook_ctx)
+        session = get_existing_session(session_key, scopes)
+
+        if session.nil?
+          token_url = resolve_token_endpoint(hook_ctx.base_url, credentials.token_url)
+          session = do_token_request(token_url, credentials, scopes)
+          store_session(session_key, scopes, session)
+        end
+
+        request.headers['Authorization'] = "Bearer #{session.token}"
+        request
+      end
+
+      sig do
+        override.params(
+          error: T.nilable(StandardError),
+          hook_ctx: AfterErrorHookContext,
+          response: T.nilable(Faraday::Response)
+        ).returns(T.nilable(Faraday::Response))
+      end
+      def after_error(error:, hook_ctx:, response:)
+        return response if hook_disabled?(hook_ctx)
+
+        # We don't want to refresh the token if the error is not related to the token
+        return response unless error.nil?
+
+        credentials = get_credentials(hook_ctx)
+        return response if credentials.nil?
+
+        if !response.nil? && response.status == 401
+          session_key = get_session_key(credentials.client_id, credentials.client_secret)
+          scopes = get_required_scopes(credentials, hook_ctx)
+          scope_key = get_scope_key(scopes)
+          remove_session(session_key, scope_key)
+        end
+
+        response
+      end
+
+      private
+
+      sig { params(hook_ctx: HookContext).returns(T::Boolean) }
+      def hook_disabled?(hook_ctx)
+        hook_ctx.oauth2_scopes.nil?
+      end
+
+
+      sig { params(hook_ctx: HookContext).returns(T.nilable(Credentials)) }
+      def get_credentials(hook_ctx)
+        source = hook_ctx.security_source
+        return nil if source.nil?
+
+        security = source.call
+
+        case hook_ctx.operation_id
+        when 'uploadAvatar'
+          return get_credentials_upload_avatar(security)
+        when 'deleteAvatar'
+          return get_credentials_delete_avatar(security)
+        end
+        
+        nil
+      end
+
+
+      sig { params(security: T.untyped).returns(T.nilable(Credentials)) }
+      def get_credentials_upload_avatar(security)
+        return nil if security.nil? || security.o_auth2_auth.nil?
+        
+        # Extract additional properties from security object
+        additional_properties = {}
+        security.o_auth2_auth.class.fields.each do |f|
+          name = f.name.to_s
+          next if %w[client_id client_secret token_url scopes].include?(name)
+        
+          metadata = f.metadata&.dig(:security)
+          next if metadata.nil?
+        
+          field_name = metadata[:field_name] || name
+          value = security.o_auth2_auth.send(f.name)
+          additional_properties[field_name] = value.to_s unless value.nil?
+        end
+        
+        Credentials.new(
+          client_id: security.o_auth2_auth.client_id,
+          client_secret: security.o_auth2_auth.client_secret,
+          token_url: security.o_auth2_auth.token_url,
+          scopes: nil,
+          additional_properties: additional_properties
+        )
+      end
+
+      sig { params(security: T.untyped).returns(T.nilable(Credentials)) }
+      def get_credentials_delete_avatar(security)
+        return nil if security.nil? || security.o_auth2_auth.nil?
+        
+        # Extract additional properties from security object
+        additional_properties = {}
+        security.o_auth2_auth.class.fields.each do |f|
+          name = f.name.to_s
+          next if %w[client_id client_secret token_url scopes].include?(name)
+        
+          metadata = f.metadata&.dig(:security)
+          next if metadata.nil?
+        
+          field_name = metadata[:field_name] || name
+          value = security.o_auth2_auth.send(f.name)
+          additional_properties[field_name] = value.to_s unless value.nil?
+        end
+        
+        Credentials.new(
+          client_id: security.o_auth2_auth.client_id,
+          client_secret: security.o_auth2_auth.client_secret,
+          token_url: security.o_auth2_auth.token_url,
+          scopes: nil,
+          additional_properties: additional_properties
+        )
+      end
+
+
+      sig { params(base_url: String, token_url: String).returns(String) }
+      def resolve_token_endpoint(base_url, token_url)
+        parsed = URI.parse(token_url)
+        return token_url if parsed.host
+
+        base = base_url.chomp('/')
+        URI.join("#{base}/", token_url).to_s
+      end
+
+      sig { params(token_url: String, credentials: Credentials, scopes: T::Array[String]).returns(Session) }
+      def do_token_request(token_url, credentials, scopes)
+        payload = {
+          'grant_type' => 'client_credentials',
+          'client_id' => credentials.client_id,
+          'client_secret' => credentials.client_secret
+        }
+
+        payload['scope'] = scopes.join(' ') unless scopes.empty?
+
+        # Add additional properties to payload
+        credentials.additional_properties.each do |key, value|
+          payload[key] = value
+        end
+        response = @client.post(token_url) do |req|
+          req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+          req.body = URI.encode_www_form(payload)
+        end
+
+        raise "Unexpected status code #{response.status} from token endpoint" unless response.status >= 200 && response.status < 300
+
+        response_data = JSON.parse(response.body)
+
+        raise 'Unexpected token type from token endpoint' unless response_data.fetch('token_type', '').downcase == 'bearer'
+
+        expires_at = nil
+        if response_data.key?('expires_in')
+          expires_at = Time.now.to_i + response_data['expires_in'].to_i
+        end
+
+        Session.new(
+          credentials: credentials,
+          token: response_data['access_token'],
+          scopes: scopes,
+          expires_at: expires_at
+        )
+      end
+
+      sig { params(client_id: String, client_secret: String).returns(String) }
+      def get_session_key(client_id, client_secret)
+        Digest::MD5.hexdigest("#{client_id}:#{client_secret}")
+      end
+
+      sig { params(credentials: Credentials, hook_ctx: HookContext).returns(T::Array[String]) }
+      def get_required_scopes(credentials, hook_ctx)
+        return T.must(credentials.scopes) unless credentials.scopes.nil?
+
+        hook_ctx.oauth2_scopes || []
+      end
+
+      sig { params(scopes: T::Array[String]).returns(String) }
+      def get_scope_key(scopes)
+        return '' if scopes.empty?
+
+        scopes.sort.join('&')
+      end
+
+      sig { params(client_key: String, scopes: T::Array[String], session: Session).void }
+      def store_session(client_key, scopes, session)
+        scope_key = get_scope_key(scopes)
+        lock = get_client_lock(client_key)
+        lock.synchronize do
+          self.class.sessions[client_key] ||= {}
+          self.class.sessions[client_key][scope_key] = session
+        end
+      end
+
+      sig { params(client_key: String, scope_key: String).void }
+      def remove_session(client_key, scope_key)
+        lock = get_client_lock(client_key)
+        lock.synchronize do
+          if self.class.sessions.key?(client_key) && self.class.sessions[client_key].key?(scope_key)
+            self.class.sessions[client_key].delete(scope_key)
+            self.class.sessions.delete(client_key) if self.class.sessions[client_key].empty?
+          end
+        end
+      end
+
+      sig { params(client_key: String, required_scopes: T::Array[String]).returns(T.nilable(Session)) }
+      def get_existing_session(client_key, required_scopes)
+        scope_key = get_scope_key(required_scopes)
+        expired_keys = []
+        result = T.let(nil, T.untyped)
+
+        lock = get_client_lock(client_key)
+        lock.synchronize do
+          return nil unless self.class.sessions.key?(client_key)
+
+          client_sessions = self.class.sessions[client_key]
+
+          # Check for exact scope match first
+          if client_sessions.key?(scope_key)
+            exact_match = client_sessions[scope_key]
+            if token_expired?(exact_match.expires_at)
+              expired_keys << scope_key
+            else
+              result = exact_match
+            end
+          end
+
+          # If no exact match, look for a superset match
+          if result.nil?
+            found = T.let(false, T::Boolean)
+            client_sessions.each do |key, session|
+              if token_expired?(session.expires_at)
+                expired_keys << key
+              elsif !found && required_scopes?(session.scopes, required_scopes)
+                result = session
+                found = true
+              end
+            end
+          end
+
+          # Clean up expired sessions
+          expired_keys.each { |key| client_sessions.delete(key) }
+
+          # Clean up empty client sessions
+          self.class.sessions.delete(client_key) if self.class.sessions.key?(client_key) && self.class.sessions[client_key].empty?
+        end
+
+        result
+      end
+
+      sig { params(scopes: T::Array[String], required_scopes: T::Array[String]).returns(T::Boolean) }
+      def required_scopes?(scopes, required_scopes)
+        required_scopes.all? { |scope| scopes.include?(scope) }
+      end
+
+      sig { params(expires_at: T.nilable(Integer)).returns(T::Boolean) }
+      def token_expired?(expires_at)
+        !expires_at.nil? && Time.now.to_i + 60 >= expires_at
+      end
+
+      sig { params(client_key: String).returns(Mutex) }
+      def get_client_lock(client_key)
+        self.class.global_lock.synchronize do
+          self.class.client_locks[client_key] ||= Mutex.new
+        end
+      end
+    end
+  end
+end

data/lib/moov/sdk_hooks/hooks.rb

@@ -5,6 +5,8 @@
 
 require_relative './types'
 require_relative './registration'
+require_relative './oauth2scopes'
+require_relative './clientcredentials'
 
 module Moov
   module SDKHooks
@@ -17,6 +19,10 @@ module Moov
         @before_request_hooks = T.let([], T::Array[AbstractSDKHook])
         @after_success_hooks = T.let([], T::Array[AbstractSDKHook])
         @after_error_hooks = T.let([], T::Array[AbstractSDKHook])
+        cc_hook = ClientCredentialsHook.new
+        register_sdk_init_hook cc_hook
+        register_before_request_hook cc_hook
+        register_after_error_hook cc_hook
         Registration.init_hooks self
       end
 

data/lib/moov/sdk_hooks/oauth2scopes.rb

@@ -0,0 +1,18 @@
+# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module Moov
+  module SDKHooks
+
+    # OAuth2AuthOAuth2Scope - Available scopes for the OAuth2Auth OAuth 2.0 scheme (clientCredentials flow).
+    class OAuth2AuthOAuth2Scope < T::Enum
+
+      enums do
+        # ROOT_ACCOUNTS_WRITE
+        ROOT_ACCOUNTS_WRITE = new('/accounts.write')
+      end
+    end
+  end
+end

data/lib/moov/sdkconfiguration.rb

@@ -88,9 +88,9 @@ module Moov
       end
       @language = 'ruby'
       @openapi_doc_version = 'dev'
-      @sdk_version = '0.0.0-dev.23'
-      @gen_version = '2.917.0'
-      @user_agent = 'speakeasy-sdk/ruby 0.0.0-dev.23 2.917.0 dev moov_ruby'
+      @sdk_version = '0.0.0-dev.24'
+      @gen_version = '2.924.0'
+      @user_agent = 'speakeasy-sdk/ruby 0.0.0-dev.24 2.924.0 dev moov_ruby'
     end
 
     sig { returns([String, T::Hash[Symbol, String]]) }