ding_sdk 0.3.0

data/lib/ding/models/shared/retryauthenticationresponse.rb

@@ -0,0 +1,64 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'faraday'
+
+module DingSDK
+  module Shared
+    # RetryAuthenticationResponseStatus - The status of the retry. Possible values are:
+    #   * `approved` - The retry was approved and a new code was sent.
+    #   * `denied` - The retry was denied.
+    #   * `no_attempt` - No attempt was sent yet, so a retry cannot be completed.
+    #   * `rate_limited` - The authentication was rate limited and cannot be retried.
+    #   * `expired_auth` - The authentication has expired and cannot be retried.
+    #   * `already_validated` - The authentication has already been validated.
+    # 
+    class RetryAuthenticationResponseStatus < T::Enum
+      enums do
+        APPROVED = new('approved')
+        DENIED = new('denied')
+        NO_ATTEMPT = new('no_attempt')
+        RATE_LIMITED = new('rate_limited')
+        EXPIRED_AUTH = new('expired_auth')
+        ALREADY_VALIDATED = new('already_validated')
+      end
+    end
+
+
+
+    class RetryAuthenticationResponse < DingSDK::Utils::FieldAugmented
+      extend T::Sig
+
+      # The UUID of the corresponding authentication.
+      field :authentication_uuid, T.nilable(String), { 'format_json': { 'letter_case': OpenApiSDK::Utils.field_name('authentication_uuid') } }
+
+      field :created_at, T.nilable(DateTime), { 'format_json': { 'letter_case': OpenApiSDK::Utils.field_name('created_at'), 'decoder': Utils.datetime_from_iso_format(true) } }
+      # The time at which the next retry will be available.
+      field :next_retry_at, T.nilable(DateTime), { 'format_json': { 'letter_case': OpenApiSDK::Utils.field_name('next_retry_at'), 'decoder': Utils.datetime_from_iso_format(true) } }
+      # The number of remaining retries.
+      field :remaining_retry, T.nilable(Integer), { 'format_json': { 'letter_case': OpenApiSDK::Utils.field_name('remaining_retry') } }
+      # The status of the retry. Possible values are:
+      #   * `approved` - The retry was approved and a new code was sent.
+      #   * `denied` - The retry was denied.
+      #   * `no_attempt` - No attempt was sent yet, so a retry cannot be completed.
+      #   * `rate_limited` - The authentication was rate limited and cannot be retried.
+      #   * `expired_auth` - The authentication has expired and cannot be retried.
+      #   * `already_validated` - The authentication has already been validated.
+      # 
+      field :status, T.nilable(Shared::RetryAuthenticationResponseStatus), { 'format_json': { 'letter_case': OpenApiSDK::Utils.field_name('status'), 'decoder': Utils.enum_from_string(Shared::RetryAuthenticationResponseStatus, true) } }
+
+
+      sig { params(authentication_uuid: T.nilable(String), created_at: T.nilable(DateTime), next_retry_at: T.nilable(DateTime), remaining_retry: T.nilable(Integer), status: T.nilable(Shared::RetryAuthenticationResponseStatus)).void }
+      def initialize(authentication_uuid: nil, created_at: nil, next_retry_at: nil, remaining_retry: nil, status: nil)
+        @authentication_uuid = authentication_uuid
+        @created_at = created_at
+        @next_retry_at = next_retry_at
+        @remaining_retry = remaining_retry
+        @status = status
+      end
+    end
+  end
+end

data/lib/ding/models/shared/security.rb

@@ -0,0 +1,25 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'faraday'
+
+module DingSDK
+  module Shared
+
+    class Security < DingSDK::Utils::FieldAugmented
+      extend T::Sig
+
+
+      field :api_key, String, { 'security': { 'scheme': true, 'type': 'apiKey', 'sub_type': 'header', 'field_name': 'x-api-key' } }
+
+
+      sig { params(api_key: String).void }
+      def initialize(api_key: nil)
+        @api_key = api_key
+      end
+    end
+  end
+end

data/lib/ding/otp.rb

@@ -0,0 +1,149 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'sorbet-runtime'
+
+module DingSDK
+  extend T::Sig
+  class Otp
+    # Send OTP codes to your users using their phone numbers.
+    extend T::Sig
+    sig { params(sdk_config: SDKConfiguration).void }
+    def initialize(sdk_config)
+      @sdk_configuration = sdk_config
+    end
+
+    sig { params(request: T.nilable(Shared::CreateCheckRequest)).returns(Utils::FieldAugmented) }
+    def check(request)
+      # check - Check a code
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/check"
+      headers = {}
+      req_content_type, data, form = Utils.serialize_request_body(request, :request, :json)
+      headers['content-type'] = req_content_type
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      r = @sdk_configuration.client.post(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk_configuration.security) if !@sdk_configuration.nil? && !@sdk_configuration.security.nil?
+        if form
+          req.body = Utils.encode_form(form)
+        elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+          req.body = URI.encode_www_form(data)
+        else
+          req.body = data
+        end
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::CheckResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::CreateCheckResponse)
+          res.create_check_response = out
+        end
+      elsif r.status == 400
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::ErrorResponse)
+          res.error_response = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: T.nilable(Shared::CreateAuthenticationRequest)).returns(Utils::FieldAugmented) }
+    def create_autentication(request)
+      # create_autentication - Send a code
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/authentication"
+      headers = {}
+      req_content_type, data, form = Utils.serialize_request_body(request, :request, :json)
+      headers['content-type'] = req_content_type
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      r = @sdk_configuration.client.post(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk_configuration.security) if !@sdk_configuration.nil? && !@sdk_configuration.security.nil?
+        if form
+          req.body = Utils.encode_form(form)
+        elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+          req.body = URI.encode_www_form(data)
+        else
+          req.body = data
+        end
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::CreateAutenticationResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::CreateAuthenticationResponse)
+          res.create_authentication_response = out
+        end
+      elsif r.status == 400
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::ErrorResponse)
+          res.error_response = out
+        end
+      end
+      res
+    end
+
+    sig { params(request: T.nilable(Shared::RetryAuthenticationRequest)).returns(Utils::FieldAugmented) }
+    def retry(request)
+      # retry - Perform a retry
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/retry"
+      headers = {}
+      req_content_type, data, form = Utils.serialize_request_body(request, :request, :json)
+      headers['content-type'] = req_content_type
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      r = @sdk_configuration.client.post(url) do |req|
+        req.headers = headers
+        Utils.configure_request_security(req, @sdk_configuration.security) if !@sdk_configuration.nil? && !@sdk_configuration.security.nil?
+        if form
+          req.body = Utils.encode_form(form)
+        elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+          req.body = URI.encode_www_form(data)
+        else
+          req.body = data
+        end
+      end
+
+      content_type = r.headers.fetch('Content-Type', 'application/octet-stream')
+
+      res = Operations::RetryResponse.new(
+        status_code: r.status, content_type: content_type, raw_response: r
+      )
+      if r.status == 200
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::RetryAuthenticationResponse)
+          res.retry_authentication_response = out
+        end
+      elsif r.status == 400
+        if Utils.match_content_type(content_type, 'application/json')
+          out = Utils.unmarshal_complex(r.env.response_body, Shared::ErrorResponse)
+          res.error_response = out
+        end
+      end
+      res
+    end
+  end
+end

data/lib/ding/sdk.rb

@@ -0,0 +1,89 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'sorbet-runtime'
+module DingSDK
+  extend T::Sig
+
+  class Ding
+    extend T::Sig
+
+    attr_accessor :otp, :lookup
+
+    attr_accessor :security, :language, :sdk_version, :gen_version
+
+    sig do
+      params(security: T.nilable(Shared::Security),
+             server: String,
+             server_url: String,
+             url_params: T::Hash[Symbol, String],
+             client: Faraday::Request).void
+    end
+    def initialize(security: nil,
+                   server: nil,
+                   server_url: nil,
+                   url_params: nil,
+                   client: nil)
+
+      ## Instantiates the SDK configuring it with the provided parameters.
+      # @param [Shared::Security] security The security details required for authentication
+      # @param [String] server The server by name to use for all operations
+      # @param [String] server_url The server URL to use for all operations
+      # @param [Hash<Symbol, String>] url_params Parameters to optionally template the server URL with
+      # @param [Faraday::Request] client The faraday HTTP client to use for all operations
+
+      if client.nil?
+        client = Faraday.new(request: {
+                          params_encoder: Faraday::FlatParamsEncoder
+                        }) do |f|
+          f.request :multipart, {}
+          # f.response :logger
+        end
+      end
+
+      if !server_url.nil?
+        if !url_params.nil?
+          server_url = Utils.template_url(server_url, url_params)
+        end
+      end
+      server = SERVER_PRODUCTION if server.nil?
+
+      
+
+      @sdk_configuration = SDKConfiguration.new(client, security, server_url, server)
+      init_sdks
+    end
+
+    sig { params(params: T.nilable(T::Hash[Symbol, String])).void }
+    def config_server_url(params)
+      if !params.nil?
+        @server_url = Utils.template_url(@server_url, params)
+      end
+      init_sdks
+    end
+
+    sig { params(server: String, params: T.nilable(T::Hash[Symbol, String])).void }
+    def config_server(params)
+      raise StandardError, 'Invalid server' if !SERVERS.include? server
+
+      config_server_url(params)
+      init_sdks
+    end
+
+    sig { params(security: Shared::Security).void }
+    def config_security(security)
+      @security = security
+      @sdk_configuration.security = security
+    end
+
+    sig { void }
+    def init_sdks
+      @otp = Otp.new(@sdk_configuration)
+      @lookup = Lookup.new(@sdk_configuration)
+    end
+  end
+end

data/lib/ding/sdkconfiguration.rb

@@ -0,0 +1,55 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'sorbet-runtime'
+
+module OpenApiSDK
+  extend T::Sig
+
+
+  SERVER_PRODUCTION = 'production' # The production Ding API server
+  SERVERS = {
+    SERVER_PRODUCTION: 'https://api.ding.live/v1',
+  }.freeze
+  # Contains the list of servers available to the SDK
+
+
+  class SDKConfiguration < OpenApiSDK::Utils::FieldAugmented
+    extend T::Sig
+
+    field :client, T.nilable(Faraday::Connection)
+    field :security, Shared::Security
+    field :server_url, T.nilable(String)
+    field :server, T.nilable(String)
+    field :server_defaults, Hash[Symbol, Hash[Symbol, String]], { 'default_factory': Hash}
+    field :language, String
+    field :openapi_doc_version, String
+    field :sdk_version, String
+    field :gen_version, String
+    field :user_agent, String
+  
+    
+    sig { params(client: Faraday::Connection, security: T.nilable(Shared::Security), server_url: T.nilable(String), server_idx: T.nilable(Integer), server_defaults: T::Hash[Symbol, String], globals: T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]]).void }
+    def initialize(client, security, server_url, server_idx, server_defaults, globals)
+      @client = client
+      @server = server_url.nil? ? '' : server_url
+      @language = 'ruby'
+      @openapi_doc_version = '1.0.0'
+      @sdk_version = '0.3.0'
+      @gen_version = '2.189.1'
+      @user_agent = 'speakeasy-sdk/ruby 0.3.0 2.189.1 1.0.0 ding_sdk'
+    end
+
+    sig { returns([String, T::Hash[Symbol, String]]) }
+    def get_server_details
+      return [@server_url.delete_suffix('/'), {}] if !@server_url.nil?
+      @server = SERVER_PRODUCTION if @server.nil?
+
+      [SERVERS[@server], {}]
+    end
+  end
+end

data/lib/ding/utils/metadata_fields.rb

@@ -0,0 +1,154 @@
+# Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
+
+# typed: true
+# frozen_string_literal: true
+
+module DingSDK
+  module MetadataFields
+    extend T::Sig
+
+    class Field
+      attr_accessor :name, :type, :metadata
+
+      def initialize(name, type, metadata)
+        @name = name
+        @type = type
+        @metadata = metadata
+      end
+    end
+
+    module ClassMethods
+      extend T::Sig
+
+      def fields
+        @__fields__ = [] if @__fields__.nil?
+
+        @__fields__
+      end
+
+      def field(field_name, type, metadata = {})
+        attr_accessor field_name
+
+        fields << Field.new(field_name, type, metadata)
+      end
+
+      def unmarshal_single(field_type, value, decoder = nil)
+        if field_type.respond_to? :unmarshal_json
+          unmarshalled = field_type.unmarshal_json(value)
+          return unmarshalled
+        elsif field_type.to_s == 'Object'
+          # rubocop:disable Lint/SuppressedException
+          begin
+            value = JSON.parse(value)
+          rescue TypeError, JSON::ParserError
+          end
+          # rubocop:enable Lint/SuppressedException
+          return value
+        end
+        if decoder.nil?
+          value
+        else
+          decoder.call(value)
+        end
+      end
+
+      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Utils::FieldAugmented) }
+      def unmarshal_json(json_obj)
+        to_build = new
+        begin
+          d = JSON.parse(json_obj)
+        rescue TypeError, JSON::ParserError
+          d = json_obj
+        end
+        fields.each do |field|
+          field_type = field.type
+          if field.type.respond_to?(:types) && field.type.types.length == 2
+            type2 = field.type.types[1]
+            if type2.raw_type == NilClass
+              field_type = field.type.types[0]
+              field_type = field_type.raw_type if field_type.respond_to? :raw_type
+            end
+          end
+
+
+          key = "#{field.name}="
+          lookup = field.metadata.fetch(:format_json, {}).fetch(:letter_case, nil).call
+          value = d[lookup]
+          next if value.nil?
+
+          if field_type.to_s.start_with? 'T::Array'
+            inner_type = field_type.type.raw_type
+            unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f) }
+            to_build.send(key, unmarshalled_array)
+          elsif field_type.to_s.start_with? 'T::Hash'
+            _, val_type = field_type.type.types
+            # rubocop:disable Style/HashTransformValues
+            unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type.raw_type, v)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+            to_build.send(key, unmarshalled_hash)
+          else
+            decoder = field.metadata.fetch(:format_json, {}).fetch(:decoder, nil)
+            final_value = unmarshal_single(field_type, value, decoder)
+            to_build.send(key, final_value)
+          end
+        end
+        to_build
+      end
+    end
+
+    def initialize
+      instance = allocate
+      fields.each { |mod| instance.singleton_class.include(mod) }
+      instance.send(:initialize)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def field(field_name)
+      fields.each do |f|
+        return f if f.name == field_name
+      end
+    end
+
+    def marshal_single(field)
+      if field.respond_to? :marshal_json
+        field.marshal_json(encode: false)
+      else
+        Utils.val_to_string(field, primitives: false)
+      end
+    end
+
+    def marshal_json(encode: true)
+      d = {}
+      fields.sort_by(&:name).each do |field|
+        f = send(field.name)
+        next if f.nil?
+
+        format_json_meta = field.metadata[:format_json]
+        if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
+          key = format_json_meta[:letter_case].call(field.name)
+        else
+          key = field.name
+        end
+        if f.is_a? Array
+          d[key] = f.map { |o| marshal_single(o) }
+        elsif f.is_a? Hash
+          d[key] = f.map { |k, v| [k, marshal_single(v)] }
+        else
+          d[key] = marshal_single(f)
+        end
+      end
+      if encode
+        JSON.dump(d)
+      else
+        d
+      end
+    end
+  end
+end