candidhealth 0.0.0

data/lib/candidhealth/pre_encounter/eligibility_checks/v_1/client.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require_relative "../../../../requests"
+require_relative "types/eligibility_request"
+require_relative "types/eligibility_response"
+require_relative "types/batch_eligibility_response"
+require_relative "types/eligibility_check_page"
+require "async"
+
+module CandidApiClient
+  module PreEncounter
+    module EligibilityChecks
+      module V1
+        class V1Client
+          # @return [CandidApiClient::RequestClient]
+          attr_reader :request_client
+
+          # @param request_client [CandidApiClient::RequestClient]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::V1Client]
+          def initialize(request_client:)
+            @request_client = request_client
+          end
+
+          # Sends real-time eligibility checks to payers through Stedi.
+          #  <Warning>Please only send one concurrent request to this endpoint. Batch
+          #  requests must be made in succession, otherwise, it will cause this service to
+          #  fail. A batch endpoint is in development - please reach out to the Candid team
+          #  for more information.</Warning>
+          #
+          # @param request [Hash] Request of type CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest, as a Hash
+          #   * :submitter_transaction_identifier (String)
+          #   * :payer_id (String)
+          #   * :provider (Hash)
+          #   * :subscriber (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :dependent (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :encounter (Hash)
+          #     * :date_of_service (Date)
+          #     * :service_type_codes (Array<String>)
+          # @param request_options [CandidApiClient::RequestOptions]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::ELIGIBILITY_RESPONSE]
+          # @example
+          #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+          #  api.pre_encounter.eligibility_checks.v_1.post(request: { payer_id: "payer_id", provider: { npi: "npi" }, subscriber: { first_name: "first_name", last_name: "last_name" } })
+          def post(request:, request_options: nil)
+            response = @request_client.conn.post do |req|
+              req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+              req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+              req.headers = {
+            **(req.headers || {}),
+            **@request_client.get_headers,
+            **(request_options&.additional_headers || {})
+              }.compact
+              req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+              req.url "#{@request_client.get_url(environment: PreEncounter,
+                                                 request_options: request_options)}/eligibility-checks/v1"
+            end
+            CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheck.from_json(json_object: response.body)
+          end
+
+          # Sends a batch of eligibility checks to payers through Stedi.
+          #
+          # @param request [Array<Hash>] Request of type Array<CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest>, as a Hash
+          #   * :submitter_transaction_identifier (String)
+          #   * :payer_id (String)
+          #   * :provider (Hash)
+          #   * :subscriber (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :dependent (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :encounter (Hash)
+          #     * :date_of_service (Date)
+          #     * :service_type_codes (Array<String>)
+          # @param request_options [CandidApiClient::RequestOptions]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::BatchEligibilityResponse]
+          # @example
+          #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+          #  api.pre_encounter.eligibility_checks.v_1.batch(request: [{ payer_id: "payer_id", provider: { npi: "npi" }, subscriber: { first_name: "first_name", last_name: "last_name" } }, { payer_id: "payer_id", provider: { npi: "npi" }, subscriber: { first_name: "first_name", last_name: "last_name" } }])
+          def batch(request:, request_options: nil)
+            response = @request_client.conn.post do |req|
+              req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+              req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+              req.headers = {
+            **(req.headers || {}),
+            **@request_client.get_headers,
+            **(request_options&.additional_headers || {})
+              }.compact
+              req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+              req.url "#{@request_client.get_url(environment: PreEncounter,
+                                                 request_options: request_options)}/eligibility-checks/v1/batch"
+            end
+            CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::BatchEligibilityResponse.from_json(json_object: response.body)
+          end
+
+          # Polls the status of a batch eligibility check.
+          #  <Note>Batch eligibility checks are not yet available. Please reach out to the
+          #  Candid team for more information.</Note>
+          #  path-parameters:
+          #
+          # @param batch_id [String]
+          # @param request_options [CandidApiClient::RequestOptions]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckPage]
+          # @example
+          #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+          #  api.pre_encounter.eligibility_checks.v_1.poll_batch(batch_id: "batch_id")
+          def poll_batch(batch_id:, request_options: nil)
+            response = @request_client.conn.get do |req|
+              req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+              req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+              req.headers = {
+            **(req.headers || {}),
+            **@request_client.get_headers,
+            **(request_options&.additional_headers || {})
+              }.compact
+              req.url "#{@request_client.get_url(environment: PreEncounter,
+                                                 request_options: request_options)}/eligibility-checks/v1/batch/#{batch_id}"
+            end
+            CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckPage.from_json(json_object: response.body)
+          end
+        end
+
+        class AsyncV1Client
+          # @return [CandidApiClient::AsyncRequestClient]
+          attr_reader :request_client
+
+          # @param request_client [CandidApiClient::AsyncRequestClient]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::AsyncV1Client]
+          def initialize(request_client:)
+            @request_client = request_client
+          end
+
+          # Sends real-time eligibility checks to payers through Stedi.
+          #  <Warning>Please only send one concurrent request to this endpoint. Batch
+          #  requests must be made in succession, otherwise, it will cause this service to
+          #  fail. A batch endpoint is in development - please reach out to the Candid team
+          #  for more information.</Warning>
+          #
+          # @param request [Hash] Request of type CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest, as a Hash
+          #   * :submitter_transaction_identifier (String)
+          #   * :payer_id (String)
+          #   * :provider (Hash)
+          #   * :subscriber (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :dependent (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :encounter (Hash)
+          #     * :date_of_service (Date)
+          #     * :service_type_codes (Array<String>)
+          # @param request_options [CandidApiClient::RequestOptions]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::ELIGIBILITY_RESPONSE]
+          # @example
+          #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+          #  api.pre_encounter.eligibility_checks.v_1.post(request: { payer_id: "payer_id", provider: { npi: "npi" }, subscriber: { first_name: "first_name", last_name: "last_name" } })
+          def post(request:, request_options: nil)
+            Async do
+              response = @request_client.conn.post do |req|
+                req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+                req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+                req.headers = {
+              **(req.headers || {}),
+              **@request_client.get_headers,
+              **(request_options&.additional_headers || {})
+                }.compact
+                req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+                req.url "#{@request_client.get_url(environment: PreEncounter,
+                                                   request_options: request_options)}/eligibility-checks/v1"
+              end
+              CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheck.from_json(json_object: response.body)
+            end
+          end
+
+          # Sends a batch of eligibility checks to payers through Stedi.
+          #
+          # @param request [Array<Hash>] Request of type Array<CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest>, as a Hash
+          #   * :submitter_transaction_identifier (String)
+          #   * :payer_id (String)
+          #   * :provider (Hash)
+          #   * :subscriber (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :dependent (Hash)
+          #     * :member_id (String)
+          #     * :first_name (String)
+          #     * :last_name (String)
+          #     * :date_of_birth (Date)
+          #   * :encounter (Hash)
+          #     * :date_of_service (Date)
+          #     * :service_type_codes (Array<String>)
+          # @param request_options [CandidApiClient::RequestOptions]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::BatchEligibilityResponse]
+          # @example
+          #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+          #  api.pre_encounter.eligibility_checks.v_1.batch(request: [{ payer_id: "payer_id", provider: { npi: "npi" }, subscriber: { first_name: "first_name", last_name: "last_name" } }, { payer_id: "payer_id", provider: { npi: "npi" }, subscriber: { first_name: "first_name", last_name: "last_name" } }])
+          def batch(request:, request_options: nil)
+            Async do
+              response = @request_client.conn.post do |req|
+                req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+                req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+                req.headers = {
+              **(req.headers || {}),
+              **@request_client.get_headers,
+              **(request_options&.additional_headers || {})
+                }.compact
+                req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+                req.url "#{@request_client.get_url(environment: PreEncounter,
+                                                   request_options: request_options)}/eligibility-checks/v1/batch"
+              end
+              CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::BatchEligibilityResponse.from_json(json_object: response.body)
+            end
+          end
+
+          # Polls the status of a batch eligibility check.
+          #  <Note>Batch eligibility checks are not yet available. Please reach out to the
+          #  Candid team for more information.</Note>
+          #  path-parameters:
+          #
+          # @param batch_id [String]
+          # @param request_options [CandidApiClient::RequestOptions]
+          # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckPage]
+          # @example
+          #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+          #  api.pre_encounter.eligibility_checks.v_1.poll_batch(batch_id: "batch_id")
+          def poll_batch(batch_id:, request_options: nil)
+            Async do
+              response = @request_client.conn.get do |req|
+                req.options.timeout = request_options.timeout_in_seconds unless request_options&.timeout_in_seconds.nil?
+                req.headers["Authorization"] = request_options.token unless request_options&.token.nil?
+                req.headers = {
+              **(req.headers || {}),
+              **@request_client.get_headers,
+              **(request_options&.additional_headers || {})
+                }.compact
+                req.url "#{@request_client.get_url(environment: PreEncounter,
+                                                   request_options: request_options)}/eligibility-checks/v1/batch/#{batch_id}"
+              end
+              CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckPage.from_json(json_object: response.body)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/pre_encounter/eligibility_checks/v_1/types/batch_eligibility_response.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "date"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PreEncounter
+    module EligibilityChecks
+      module V1
+        module Types
+          # An object representing the data for a batch eligibility response.
+          class BatchEligibilityResponse
+            # @return [String]
+            attr_reader :batch_id
+            # @return [DateTime]
+            attr_reader :submitted_at
+            # @return [OpenStruct] Additional properties unmapped to the current class definition
+            attr_reader :additional_properties
+            # @return [Object]
+            attr_reader :_field_set
+            protected :_field_set
+
+            OMIT = Object.new
+
+            # @param batch_id [String]
+            # @param submitted_at [DateTime]
+            # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::BatchEligibilityResponse]
+            def initialize(batch_id:, submitted_at:, additional_properties: nil)
+              @batch_id = batch_id
+              @submitted_at = submitted_at
+              @additional_properties = additional_properties
+              @_field_set = { "batch_id": batch_id, "submitted_at": submitted_at }
+            end
+
+            # Deserialize a JSON object to an instance of BatchEligibilityResponse
+            #
+            # @param json_object [String]
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::BatchEligibilityResponse]
+            def self.from_json(json_object:)
+              struct = JSON.parse(json_object, object_class: OpenStruct)
+              parsed_json = JSON.parse(json_object)
+              batch_id = struct["batch_id"]
+              submitted_at = (DateTime.parse(parsed_json["submitted_at"]) unless parsed_json["submitted_at"].nil?)
+              new(
+                batch_id: batch_id,
+                submitted_at: submitted_at,
+                additional_properties: struct
+              )
+            end
+
+            # Serialize an instance of BatchEligibilityResponse to a JSON object
+            #
+            # @return [String]
+            def to_json(*_args)
+              @_field_set&.to_json
+            end
+
+            # Leveraged for Union-type generation, validate_raw attempts to parse the given
+            #  hash and check each fields type against the current object's property
+            #  definitions.
+            #
+            # @param obj [Object]
+            # @return [Void]
+            def self.validate_raw(obj:)
+              obj.batch_id.is_a?(String) != false || raise("Passed value for field obj.batch_id is not the expected type, validation failed.")
+              obj.submitted_at.is_a?(DateTime) != false || raise("Passed value for field obj.submitted_at is not the expected type, validation failed.")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/pre_encounter/eligibility_checks/v_1/types/eligibility_check.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "eligibility_check_error"
+require_relative "eligibility_request"
+require_relative "parsed_response"
+require_relative "request_correction"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PreEncounter
+    module EligibilityChecks
+      module V1
+        module Types
+          class EligibilityCheck
+            # @return [String]
+            attr_reader :batch_id
+            # @return [Array<CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckError>]
+            attr_reader :errors
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest]
+            attr_reader :request
+            # @return [Object]
+            attr_reader :response
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::ParsedResponse]
+            attr_reader :parsed_response
+            # @return [Array<CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::RequestCorrection>]
+            attr_reader :request_corrections
+            # @return [OpenStruct] Additional properties unmapped to the current class definition
+            attr_reader :additional_properties
+            # @return [Object]
+            attr_reader :_field_set
+            protected :_field_set
+
+            OMIT = Object.new
+
+            # @param batch_id [String]
+            # @param errors [Array<CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckError>]
+            # @param request [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest]
+            # @param response [Object]
+            # @param parsed_response [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::ParsedResponse]
+            # @param request_corrections [Array<CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::RequestCorrection>]
+            # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheck]
+            def initialize(response:, batch_id: OMIT, errors: OMIT, request: OMIT, parsed_response: OMIT,
+                           request_corrections: OMIT, additional_properties: nil)
+              @batch_id = batch_id if batch_id != OMIT
+              @errors = errors if errors != OMIT
+              @request = request if request != OMIT
+              @response = response
+              @parsed_response = parsed_response if parsed_response != OMIT
+              @request_corrections = request_corrections if request_corrections != OMIT
+              @additional_properties = additional_properties
+              @_field_set = {
+                "batch_id": batch_id,
+                "errors": errors,
+                "request": request,
+                "response": response,
+                "parsed_response": parsed_response,
+                "request_corrections": request_corrections
+              }.reject do |_k, v|
+                v == OMIT
+              end
+            end
+
+            # Deserialize a JSON object to an instance of EligibilityCheck
+            #
+            # @param json_object [String]
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheck]
+            def self.from_json(json_object:)
+              struct = JSON.parse(json_object, object_class: OpenStruct)
+              parsed_json = JSON.parse(json_object)
+              batch_id = struct["batch_id"]
+              errors = parsed_json["errors"]&.map do |item|
+                item = item.to_json
+                CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckError.from_json(json_object: item)
+              end
+              if parsed_json["request"].nil?
+                request = nil
+              else
+                request = parsed_json["request"].to_json
+                request = CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest.from_json(json_object: request)
+              end
+              response = struct["response"]
+              if parsed_json["parsed_response"].nil?
+                parsed_response = nil
+              else
+                parsed_response = parsed_json["parsed_response"].to_json
+                parsed_response = CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::ParsedResponse.from_json(json_object: parsed_response)
+              end
+              request_corrections = parsed_json["request_corrections"]&.map do |item|
+                item = item.to_json
+                CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::RequestCorrection.from_json(json_object: item)
+              end
+              new(
+                batch_id: batch_id,
+                errors: errors,
+                request: request,
+                response: response,
+                parsed_response: parsed_response,
+                request_corrections: request_corrections,
+                additional_properties: struct
+              )
+            end
+
+            # Serialize an instance of EligibilityCheck to a JSON object
+            #
+            # @return [String]
+            def to_json(*_args)
+              @_field_set&.to_json
+            end
+
+            # Leveraged for Union-type generation, validate_raw attempts to parse the given
+            #  hash and check each fields type against the current object's property
+            #  definitions.
+            #
+            # @param obj [Object]
+            # @return [Void]
+            def self.validate_raw(obj:)
+              obj.batch_id&.is_a?(String) != false || raise("Passed value for field obj.batch_id is not the expected type, validation failed.")
+              obj.errors&.is_a?(Array) != false || raise("Passed value for field obj.errors is not the expected type, validation failed.")
+              obj.request.nil? || CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityRequest.validate_raw(obj: obj.request)
+              obj.response.is_a?(Object) != false || raise("Passed value for field obj.response is not the expected type, validation failed.")
+              obj.parsed_response.nil? || CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::ParsedResponse.validate_raw(obj: obj.parsed_response)
+              obj.request_corrections&.is_a?(Array) != false || raise("Passed value for field obj.request_corrections is not the expected type, validation failed.")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/pre_encounter/eligibility_checks/v_1/types/eligibility_check_error.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "eligibility_check_error_source"
+require_relative "eligibility_check_error_details"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PreEncounter
+    module EligibilityChecks
+      module V1
+        module Types
+          class EligibilityCheckError
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorSource]
+            attr_reader :source
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorDetails]
+            attr_reader :error_details
+            # @return [OpenStruct] Additional properties unmapped to the current class definition
+            attr_reader :additional_properties
+            # @return [Object]
+            attr_reader :_field_set
+            protected :_field_set
+
+            OMIT = Object.new
+
+            # @param source [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorSource]
+            # @param error_details [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorDetails]
+            # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckError]
+            def initialize(source:, error_details:, additional_properties: nil)
+              @source = source
+              @error_details = error_details
+              @additional_properties = additional_properties
+              @_field_set = { "source": source, "errorDetails": error_details }
+            end
+
+            # Deserialize a JSON object to an instance of EligibilityCheckError
+            #
+            # @param json_object [String]
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckError]
+            def self.from_json(json_object:)
+              struct = JSON.parse(json_object, object_class: OpenStruct)
+              parsed_json = JSON.parse(json_object)
+              source = struct["source"]
+              if parsed_json["errorDetails"].nil?
+                error_details = nil
+              else
+                error_details = parsed_json["errorDetails"].to_json
+                error_details = CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorDetails.from_json(json_object: error_details)
+              end
+              new(
+                source: source,
+                error_details: error_details,
+                additional_properties: struct
+              )
+            end
+
+            # Serialize an instance of EligibilityCheckError to a JSON object
+            #
+            # @return [String]
+            def to_json(*_args)
+              @_field_set&.to_json
+            end
+
+            # Leveraged for Union-type generation, validate_raw attempts to parse the given
+            #  hash and check each fields type against the current object's property
+            #  definitions.
+            #
+            # @param obj [Object]
+            # @return [Void]
+            def self.validate_raw(obj:)
+              obj.source.is_a?(CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorSource) != false || raise("Passed value for field obj.source is not the expected type, validation failed.")
+              CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorDetails.validate_raw(obj: obj.error_details)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/pre_encounter/eligibility_checks/v_1/types/eligibility_check_error_details.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PreEncounter
+    module EligibilityChecks
+      module V1
+        module Types
+          # This object is our fern representation of Stedi's EligbilityCheckError object
+          #  from their API.
+          class EligibilityCheckErrorDetails
+            # @return [String]
+            attr_reader :field
+            # @return [String]
+            attr_reader :description
+            # @return [String]
+            attr_reader :location
+            # @return [String]
+            attr_reader :possible_resolutions
+            # @return [String]
+            attr_reader :code
+            # @return [String]
+            attr_reader :followup_action
+            # @return [OpenStruct] Additional properties unmapped to the current class definition
+            attr_reader :additional_properties
+            # @return [Object]
+            attr_reader :_field_set
+            protected :_field_set
+
+            OMIT = Object.new
+
+            # @param field [String]
+            # @param description [String]
+            # @param location [String]
+            # @param possible_resolutions [String]
+            # @param code [String]
+            # @param followup_action [String]
+            # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorDetails]
+            def initialize(field: OMIT, description: OMIT, location: OMIT, possible_resolutions: OMIT, code: OMIT,
+                           followup_action: OMIT, additional_properties: nil)
+              @field = field if field != OMIT
+              @description = description if description != OMIT
+              @location = location if location != OMIT
+              @possible_resolutions = possible_resolutions if possible_resolutions != OMIT
+              @code = code if code != OMIT
+              @followup_action = followup_action if followup_action != OMIT
+              @additional_properties = additional_properties
+              @_field_set = {
+                "field?": field,
+                "description?": description,
+                "location?": location,
+                "possibleResolutions?": possible_resolutions,
+                "code?": code,
+                "followupAction?": followup_action
+              }.reject do |_k, v|
+                v == OMIT
+              end
+            end
+
+            # Deserialize a JSON object to an instance of EligibilityCheckErrorDetails
+            #
+            # @param json_object [String]
+            # @return [CandidApiClient::PreEncounter::EligibilityChecks::V1::Types::EligibilityCheckErrorDetails]
+            def self.from_json(json_object:)
+              struct = JSON.parse(json_object, object_class: OpenStruct)
+              field = struct["field?"]
+              description = struct["description?"]
+              location = struct["location?"]
+              possible_resolutions = struct["possibleResolutions?"]
+              code = struct["code?"]
+              followup_action = struct["followupAction?"]
+              new(
+                field: field,
+                description: description,
+                location: location,
+                possible_resolutions: possible_resolutions,
+                code: code,
+                followup_action: followup_action,
+                additional_properties: struct
+              )
+            end
+
+            # Serialize an instance of EligibilityCheckErrorDetails to a JSON object
+            #
+            # @return [String]
+            def to_json(*_args)
+              @_field_set&.to_json
+            end
+
+            # Leveraged for Union-type generation, validate_raw attempts to parse the given
+            #  hash and check each fields type against the current object's property
+            #  definitions.
+            #
+            # @param obj [Object]
+            # @return [Void]
+            def self.validate_raw(obj:)
+              obj.field&.is_a?(String) != false || raise("Passed value for field obj.field is not the expected type, validation failed.")
+              obj.description&.is_a?(String) != false || raise("Passed value for field obj.description is not the expected type, validation failed.")
+              obj.location&.is_a?(String) != false || raise("Passed value for field obj.location is not the expected type, validation failed.")
+              obj.possible_resolutions&.is_a?(String) != false || raise("Passed value for field obj.possible_resolutions is not the expected type, validation failed.")
+              obj.code&.is_a?(String) != false || raise("Passed value for field obj.code is not the expected type, validation failed.")
+              obj.followup_action&.is_a?(String) != false || raise("Passed value for field obj.followup_action is not the expected type, validation failed.")
+            end
+          end
+        end
+      end
+    end
+  end
+end