candidhealth 0.0.0 → 0.17.1

data/lib/candidhealth/x_12/v_1/types/remittance_advice_remark_code.rb

@@ -1,59 +1,48 @@
 # frozen_string_literal: true
 
 require_relative "rarc"
-require "ostruct"
 require "json"
 
 module CandidApiClient
   module X12
     module V1
-      module Types
-        class RemittanceAdviceRemarkCode
-          # @return [CandidApiClient::X12::V1::Types::Rarc]
-          attr_reader :reason_code
-          # @return [OpenStruct] Additional properties unmapped to the current class definition
-          attr_reader :additional_properties
-          # @return [Object]
-          attr_reader :_field_set
-          protected :_field_set
+      class RemittanceAdviceRemarkCode
+        attr_reader :reason_code, :additional_properties
 
-          OMIT = Object.new
-
-          # @param reason_code [CandidApiClient::X12::V1::Types::Rarc]
-          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-          # @return [CandidApiClient::X12::V1::Types::RemittanceAdviceRemarkCode]
-          def initialize(reason_code:, additional_properties: nil)
-            @reason_code = reason_code
-            @additional_properties = additional_properties
-            @_field_set = { "reason_code": reason_code }
-          end
+        # @param reason_code [X12::V1::Rarc]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [X12::V1::RemittanceAdviceRemarkCode]
+        def initialize(reason_code:, additional_properties: nil)
+          # @type [X12::V1::Rarc]
+          @reason_code = reason_code
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
 
-          # Deserialize a JSON object to an instance of RemittanceAdviceRemarkCode
-          #
-          # @param json_object [String]
-          # @return [CandidApiClient::X12::V1::Types::RemittanceAdviceRemarkCode]
-          def self.from_json(json_object:)
-            struct = JSON.parse(json_object, object_class: OpenStruct)
-            reason_code = struct["reason_code"]
-            new(reason_code: reason_code, additional_properties: struct)
-          end
+        # Deserialize a JSON object to an instance of RemittanceAdviceRemarkCode
+        #
+        # @param json_object [JSON]
+        # @return [X12::V1::RemittanceAdviceRemarkCode]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          JSON.parse(json_object)
+          reason_code = struct.reason_code
+          new(reason_code: reason_code, additional_properties: struct)
+        end
 
-          # Serialize an instance of RemittanceAdviceRemarkCode to a JSON object
-          #
-          # @return [String]
-          def to_json(*_args)
-            @_field_set&.to_json
-          end
+        # Serialize an instance of RemittanceAdviceRemarkCode to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "reason_code": @reason_code }.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.reason_code.is_a?(CandidApiClient::X12::V1::Types::Rarc) != false || raise("Passed value for field obj.reason_code is not the expected type, validation failed.")
-          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.reason_code.is_a?(X12::V1::Rarc) != false || raise("Passed value for field obj.reason_code is not the expected type, validation failed.")
         end
       end
     end

data/lib/candidhealth.rb

@@ -2,328 +2,128 @@
 
 require_relative "environment"
 require_relative "types_export"
-require_relative "core/oauth"
 require_relative "requests"
 require_relative "candidhealth/auth/client"
 require_relative "candidhealth/billing_notes/client"
-require_relative "candidhealth/charge_capture_bundles/client"
-require_relative "candidhealth/charge_capture/client"
 require_relative "candidhealth/contracts/client"
-require_relative "candidhealth/credentialing/client"
-require_relative "candidhealth/custom_schemas/client"
 require_relative "candidhealth/eligibility/client"
-require_relative "candidhealth/encounter_attachments/client"
-require_relative "candidhealth/encounter_providers/client"
 require_relative "candidhealth/encounters/client"
 require_relative "candidhealth/expected_network_status/client"
 require_relative "candidhealth/exports/client"
-require_relative "candidhealth/external_payment_account_config/client"
-require_relative "candidhealth/fee_schedules/client"
 require_relative "candidhealth/guarantor/client"
-require_relative "candidhealth/import_invoice/client"
 require_relative "candidhealth/insurance_adjudications/client"
 require_relative "candidhealth/insurance_payments/client"
 require_relative "candidhealth/insurance_refunds/client"
-require_relative "candidhealth/medication_dispense/client"
-require_relative "candidhealth/non_insurance_payer_payments/client"
-require_relative "candidhealth/non_insurance_payer_refunds/client"
-require_relative "candidhealth/non_insurance_payers/client"
 require_relative "candidhealth/organization_service_facilities/client"
 require_relative "candidhealth/organization_providers/client"
 require_relative "candidhealth/patient_payments/client"
 require_relative "candidhealth/patient_refunds/client"
-require_relative "candidhealth/payer_plan_groups/client"
 require_relative "candidhealth/payers/client"
-require_relative "candidhealth/service_lines/client"
-require_relative "candidhealth/superbills/client"
 require_relative "candidhealth/tasks/client"
 require_relative "candidhealth/write_offs/client"
-require_relative "candidhealth/pre_encounter/client"
-require_relative "candidhealth/diagnoses/client"
 require_relative "candidhealth/service_facility/client"
+require_relative "candidhealth/auth/v_2/types/auth_get_token_request"
 
 module CandidApiClient
   class Client
-    # @return [CandidApiClient::Auth::Client]
-    attr_reader :auth
-    # @return [CandidApiClient::BillingNotes::Client]
-    attr_reader :billing_notes
-    # @return [CandidApiClient::ChargeCaptureBundles::Client]
-    attr_reader :charge_capture_bundles
-    # @return [CandidApiClient::ChargeCapture::Client]
-    attr_reader :charge_capture
-    # @return [CandidApiClient::Contracts::Client]
-    attr_reader :contracts
-    # @return [CandidApiClient::Credentialing::Client]
-    attr_reader :credentialing
-    # @return [CandidApiClient::CustomSchemas::Client]
-    attr_reader :custom_schemas
-    # @return [CandidApiClient::Eligibility::Client]
-    attr_reader :eligibility
-    # @return [CandidApiClient::EncounterAttachments::Client]
-    attr_reader :encounter_attachments
-    # @return [CandidApiClient::EncounterProviders::Client]
-    attr_reader :encounter_providers
-    # @return [CandidApiClient::Encounters::Client]
-    attr_reader :encounters
-    # @return [CandidApiClient::ExpectedNetworkStatus::Client]
-    attr_reader :expected_network_status
-    # @return [CandidApiClient::Exports::Client]
-    attr_reader :exports
-    # @return [CandidApiClient::ExternalPaymentAccountConfig::Client]
-    attr_reader :external_payment_account_config
-    # @return [CandidApiClient::FeeSchedules::Client]
-    attr_reader :fee_schedules
-    # @return [CandidApiClient::Guarantor::Client]
-    attr_reader :guarantor
-    # @return [CandidApiClient::ImportInvoice::Client]
-    attr_reader :import_invoice
-    # @return [CandidApiClient::InsuranceAdjudications::Client]
-    attr_reader :insurance_adjudications
-    # @return [CandidApiClient::InsurancePayments::Client]
-    attr_reader :insurance_payments
-    # @return [CandidApiClient::InsuranceRefunds::Client]
-    attr_reader :insurance_refunds
-    # @return [CandidApiClient::MedicationDispense::Client]
-    attr_reader :medication_dispense
-    # @return [CandidApiClient::NonInsurancePayerPayments::Client]
-    attr_reader :non_insurance_payer_payments
-    # @return [CandidApiClient::NonInsurancePayerRefunds::Client]
-    attr_reader :non_insurance_payer_refunds
-    # @return [CandidApiClient::NonInsurancePayers::Client]
-    attr_reader :non_insurance_payers
-    # @return [CandidApiClient::OrganizationServiceFacilities::Client]
-    attr_reader :organization_service_facilities
-    # @return [CandidApiClient::OrganizationProviders::Client]
-    attr_reader :organization_providers
-    # @return [CandidApiClient::PatientPayments::Client]
-    attr_reader :patient_payments
-    # @return [CandidApiClient::PatientRefunds::Client]
-    attr_reader :patient_refunds
-    # @return [CandidApiClient::PayerPlanGroups::Client]
-    attr_reader :payer_plan_groups
-    # @return [CandidApiClient::Payers::Client]
-    attr_reader :payers
-    # @return [CandidApiClient::ServiceLines::Client]
-    attr_reader :service_lines
-    # @return [CandidApiClient::Superbills::Client]
-    attr_reader :superbills
-    # @return [CandidApiClient::Tasks::Client]
-    attr_reader :tasks
-    # @return [CandidApiClient::WriteOffs::Client]
-    attr_reader :write_offs
-    # @return [CandidApiClient::PreEncounter::Client]
-    attr_reader :pre_encounter
-    # @return [CandidApiClient::DiagnosesClient]
-    attr_reader :diagnoses
-    # @return [CandidApiClient::ServiceFacilityClient]
-    attr_reader :service_facility
+    attr_reader :auth, :billing_notes, :contracts, :eligibility, :encounters, :expected_network_status, :exports,
+                :guarantor, :insurance_adjudications, :insurance_payments, :insurance_refunds, :organization_service_facilities, :organization_providers, :patient_payments, :patient_refunds, :payers, :tasks, :write_offs, :service_facility
 
-    # @param base_url [String]
-    # @param environment [CandidApiClient::Environment]
+    # @param environment [Environment]
     # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
     # @param timeout_in_seconds [Long]
-    # @param client_id [String]
-    # @param client_secret [String]
-    # @return [CandidApiClient::Client]
-    def initialize(client_id:, client_secret:, base_url: nil, environment: CandidApiClient::Environment::PRODUCTION, max_retries: nil,
-                   timeout_in_seconds: nil)
-      @oauth_provider = CandidApiClient::OauthTokenProvider.new(
-        client_id: client_id,
-        client_secret: client_secret,
-        request_client: CandidApiClient::RequestClient.new(
-          base_url: base_url,
-          environment: environment,
-          max_retries: max_retries,
-          timeout_in_seconds: timeout_in_seconds
-        )
-      )
-      @request_client = CandidApiClient::RequestClient.new(
-        base_url: base_url,
-        environment: environment,
-        max_retries: max_retries,
-        timeout_in_seconds: timeout_in_seconds,
-        token: @oauth_provider.method(:token)
-      )
-      @auth = CandidApiClient::Auth::Client.new(request_client: @request_client)
-      @billing_notes = CandidApiClient::BillingNotes::Client.new(request_client: @request_client)
-      @charge_capture_bundles = CandidApiClient::ChargeCaptureBundles::Client.new(request_client: @request_client)
-      @charge_capture = CandidApiClient::ChargeCapture::Client.new(request_client: @request_client)
-      @contracts = CandidApiClient::Contracts::Client.new(request_client: @request_client)
-      @credentialing = CandidApiClient::Credentialing::Client.new(request_client: @request_client)
-      @custom_schemas = CandidApiClient::CustomSchemas::Client.new(request_client: @request_client)
-      @eligibility = CandidApiClient::Eligibility::Client.new(request_client: @request_client)
-      @encounter_attachments = CandidApiClient::EncounterAttachments::Client.new(request_client: @request_client)
-      @encounter_providers = CandidApiClient::EncounterProviders::Client.new(request_client: @request_client)
-      @encounters = CandidApiClient::Encounters::Client.new(request_client: @request_client)
-      @expected_network_status = CandidApiClient::ExpectedNetworkStatus::Client.new(request_client: @request_client)
-      @exports = CandidApiClient::Exports::Client.new(request_client: @request_client)
-      @external_payment_account_config = CandidApiClient::ExternalPaymentAccountConfig::Client.new(request_client: @request_client)
-      @fee_schedules = CandidApiClient::FeeSchedules::Client.new(request_client: @request_client)
-      @guarantor = CandidApiClient::Guarantor::Client.new(request_client: @request_client)
-      @import_invoice = CandidApiClient::ImportInvoice::Client.new(request_client: @request_client)
-      @insurance_adjudications = CandidApiClient::InsuranceAdjudications::Client.new(request_client: @request_client)
-      @insurance_payments = CandidApiClient::InsurancePayments::Client.new(request_client: @request_client)
-      @insurance_refunds = CandidApiClient::InsuranceRefunds::Client.new(request_client: @request_client)
-      @medication_dispense = CandidApiClient::MedicationDispense::Client.new(request_client: @request_client)
-      @non_insurance_payer_payments = CandidApiClient::NonInsurancePayerPayments::Client.new(request_client: @request_client)
-      @non_insurance_payer_refunds = CandidApiClient::NonInsurancePayerRefunds::Client.new(request_client: @request_client)
-      @non_insurance_payers = CandidApiClient::NonInsurancePayers::Client.new(request_client: @request_client)
-      @organization_service_facilities = CandidApiClient::OrganizationServiceFacilities::Client.new(request_client: @request_client)
-      @organization_providers = CandidApiClient::OrganizationProviders::Client.new(request_client: @request_client)
-      @patient_payments = CandidApiClient::PatientPayments::Client.new(request_client: @request_client)
-      @patient_refunds = CandidApiClient::PatientRefunds::Client.new(request_client: @request_client)
-      @payer_plan_groups = CandidApiClient::PayerPlanGroups::Client.new(request_client: @request_client)
-      @payers = CandidApiClient::Payers::Client.new(request_client: @request_client)
-      @service_lines = CandidApiClient::ServiceLines::Client.new(request_client: @request_client)
-      @superbills = CandidApiClient::Superbills::Client.new(request_client: @request_client)
-      @tasks = CandidApiClient::Tasks::Client.new(request_client: @request_client)
-      @write_offs = CandidApiClient::WriteOffs::Client.new(request_client: @request_client)
-      @pre_encounter = CandidApiClient::PreEncounter::Client.new(request_client: @request_client)
-      @diagnoses = CandidApiClient::DiagnosesClient.new(request_client: @request_client)
-      @service_facility = CandidApiClient::ServiceFacilityClient.new(request_client: @request_client)
+    # @param options [CandidApiAuthOptions]
+    # @return [Client]
+    def initialize(options: nil, environment: Environment::PRODUCTION, max_retries: nil, timeout_in_seconds: nil)
+      token = options.get_token(environment: environment) unless options.nil?
+
+      @request_client = RequestClient.new(environment: environment, max_retries: max_retries,
+                                          timeout_in_seconds: timeout_in_seconds, token: token)
+      @auth = Auth::Client.new(request_client: @request_client)
+      @billing_notes = BillingNotes::Client.new(request_client: @request_client)
+      @contracts = Contracts::Client.new(request_client: @request_client)
+      @eligibility = Eligibility::Client.new(request_client: @request_client)
+      @encounters = Encounters::Client.new(request_client: @request_client)
+      @expected_network_status = ExpectedNetworkStatus::Client.new(request_client: @request_client)
+      @exports = Exports::Client.new(request_client: @request_client)
+      @guarantor = Guarantor::Client.new(request_client: @request_client)
+      @insurance_adjudications = InsuranceAdjudications::Client.new(request_client: @request_client)
+      @insurance_payments = InsurancePayments::Client.new(request_client: @request_client)
+      @insurance_refunds = InsuranceRefunds::Client.new(request_client: @request_client)
+      @organization_service_facilities = OrganizationServiceFacilities::Client.new(request_client: @request_client)
+      @organization_providers = OrganizationProviders::Client.new(request_client: @request_client)
+      @patient_payments = PatientPayments::Client.new(request_client: @request_client)
+      @patient_refunds = PatientRefunds::Client.new(request_client: @request_client)
+      @payers = Payers::Client.new(request_client: @request_client)
+      @tasks = Tasks::Client.new(request_client: @request_client)
+      @write_offs = WriteOffs::Client.new(request_client: @request_client)
+      @service_facility = ServiceFacilityClient.new(request_client: @request_client)
     end
   end
 
   class AsyncClient
-    # @return [CandidApiClient::Auth::AsyncClient]
-    attr_reader :auth
-    # @return [CandidApiClient::BillingNotes::AsyncClient]
-    attr_reader :billing_notes
-    # @return [CandidApiClient::ChargeCaptureBundles::AsyncClient]
-    attr_reader :charge_capture_bundles
-    # @return [CandidApiClient::ChargeCapture::AsyncClient]
-    attr_reader :charge_capture
-    # @return [CandidApiClient::Contracts::AsyncClient]
-    attr_reader :contracts
-    # @return [CandidApiClient::Credentialing::AsyncClient]
-    attr_reader :credentialing
-    # @return [CandidApiClient::CustomSchemas::AsyncClient]
-    attr_reader :custom_schemas
-    # @return [CandidApiClient::Eligibility::AsyncClient]
-    attr_reader :eligibility
-    # @return [CandidApiClient::EncounterAttachments::AsyncClient]
-    attr_reader :encounter_attachments
-    # @return [CandidApiClient::EncounterProviders::AsyncClient]
-    attr_reader :encounter_providers
-    # @return [CandidApiClient::Encounters::AsyncClient]
-    attr_reader :encounters
-    # @return [CandidApiClient::ExpectedNetworkStatus::AsyncClient]
-    attr_reader :expected_network_status
-    # @return [CandidApiClient::Exports::AsyncClient]
-    attr_reader :exports
-    # @return [CandidApiClient::ExternalPaymentAccountConfig::AsyncClient]
-    attr_reader :external_payment_account_config
-    # @return [CandidApiClient::FeeSchedules::AsyncClient]
-    attr_reader :fee_schedules
-    # @return [CandidApiClient::Guarantor::AsyncClient]
-    attr_reader :guarantor
-    # @return [CandidApiClient::ImportInvoice::AsyncClient]
-    attr_reader :import_invoice
-    # @return [CandidApiClient::InsuranceAdjudications::AsyncClient]
-    attr_reader :insurance_adjudications
-    # @return [CandidApiClient::InsurancePayments::AsyncClient]
-    attr_reader :insurance_payments
-    # @return [CandidApiClient::InsuranceRefunds::AsyncClient]
-    attr_reader :insurance_refunds
-    # @return [CandidApiClient::MedicationDispense::AsyncClient]
-    attr_reader :medication_dispense
-    # @return [CandidApiClient::NonInsurancePayerPayments::AsyncClient]
-    attr_reader :non_insurance_payer_payments
-    # @return [CandidApiClient::NonInsurancePayerRefunds::AsyncClient]
-    attr_reader :non_insurance_payer_refunds
-    # @return [CandidApiClient::NonInsurancePayers::AsyncClient]
-    attr_reader :non_insurance_payers
-    # @return [CandidApiClient::OrganizationServiceFacilities::AsyncClient]
-    attr_reader :organization_service_facilities
-    # @return [CandidApiClient::OrganizationProviders::AsyncClient]
-    attr_reader :organization_providers
-    # @return [CandidApiClient::PatientPayments::AsyncClient]
-    attr_reader :patient_payments
-    # @return [CandidApiClient::PatientRefunds::AsyncClient]
-    attr_reader :patient_refunds
-    # @return [CandidApiClient::PayerPlanGroups::AsyncClient]
-    attr_reader :payer_plan_groups
-    # @return [CandidApiClient::Payers::AsyncClient]
-    attr_reader :payers
-    # @return [CandidApiClient::ServiceLines::AsyncClient]
-    attr_reader :service_lines
-    # @return [CandidApiClient::Superbills::AsyncClient]
-    attr_reader :superbills
-    # @return [CandidApiClient::Tasks::AsyncClient]
-    attr_reader :tasks
-    # @return [CandidApiClient::WriteOffs::AsyncClient]
-    attr_reader :write_offs
-    # @return [CandidApiClient::PreEncounter::AsyncClient]
-    attr_reader :pre_encounter
-    # @return [CandidApiClient::AsyncDiagnosesClient]
-    attr_reader :diagnoses
-    # @return [CandidApiClient::AsyncServiceFacilityClient]
-    attr_reader :service_facility
+    attr_reader :auth, :billing_notes, :contracts, :eligibility, :encounters, :expected_network_status, :exports,
+                :guarantor, :insurance_adjudications, :insurance_payments, :insurance_refunds, :organization_service_facilities, :organization_providers, :patient_payments, :patient_refunds, :payers, :tasks, :write_offs, :service_facility
 
-    # @param base_url [String]
-    # @param environment [CandidApiClient::Environment]
+    # @param environment [Environment]
     # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
     # @param timeout_in_seconds [Long]
+    # @param options [CandidApiAuthOptions]
+    # @return [AsyncClient]
+    def initialize(options: nil, environment: Environment::PRODUCTION, max_retries: nil, timeout_in_seconds: nil)
+      token = options.get_token(environment: environment) unless options.nil?
+
+      @async_request_client = AsyncRequestClient.new(environment: environment, max_retries: max_retries,
+                                                     timeout_in_seconds: timeout_in_seconds, token: token)
+      @auth = Auth::AsyncClient.new(request_client: @async_request_client)
+      @billing_notes = BillingNotes::AsyncClient.new(request_client: @async_request_client)
+      @contracts = Contracts::AsyncClient.new(request_client: @async_request_client)
+      @eligibility = Eligibility::AsyncClient.new(request_client: @async_request_client)
+      @encounters = Encounters::AsyncClient.new(request_client: @async_request_client)
+      @expected_network_status = ExpectedNetworkStatus::AsyncClient.new(request_client: @async_request_client)
+      @exports = Exports::AsyncClient.new(request_client: @async_request_client)
+      @guarantor = Guarantor::AsyncClient.new(request_client: @async_request_client)
+      @insurance_adjudications = InsuranceAdjudications::AsyncClient.new(request_client: @async_request_client)
+      @insurance_payments = InsurancePayments::AsyncClient.new(request_client: @async_request_client)
+      @insurance_refunds = InsuranceRefunds::AsyncClient.new(request_client: @async_request_client)
+      @organization_service_facilities = OrganizationServiceFacilities::AsyncClient.new(request_client: @async_request_client)
+      @organization_providers = OrganizationProviders::AsyncClient.new(request_client: @async_request_client)
+      @patient_payments = PatientPayments::AsyncClient.new(request_client: @async_request_client)
+      @patient_refunds = PatientRefunds::AsyncClient.new(request_client: @async_request_client)
+      @payers = Payers::AsyncClient.new(request_client: @async_request_client)
+      @tasks = Tasks::AsyncClient.new(request_client: @async_request_client)
+      @write_offs = WriteOffs::AsyncClient.new(request_client: @async_request_client)
+      @service_facility = AsyncServiceFacilityClient.new(request_client: @async_request_client)
+    end
+  end
+
+  class CandidApiAuthOptions
+    attr_reader :token, :client_id, :client_secret
+
+    # @param token [String]
     # @param client_id [String]
     # @param client_secret [String]
-    # @return [CandidApiClient::AsyncClient]
-    def initialize(client_id:, client_secret:, base_url: nil, environment: CandidApiClient::Environment::PRODUCTION, max_retries: nil,
-                   timeout_in_seconds: nil)
-      @oauth_provider = CandidApiClient::OauthTokenProvider.new(
-        client_id: client_id,
-        client_secret: client_secret,
-        request_client: CandidApiClient::RequestClient.new(
-          base_url: base_url,
-          environment: environment,
-          max_retries: max_retries,
-          timeout_in_seconds: timeout_in_seconds
-        )
-      )
-      @async_request_client = CandidApiClient::AsyncRequestClient.new(
-        base_url: base_url,
-        environment: environment,
-        max_retries: max_retries,
-        timeout_in_seconds: timeout_in_seconds,
-        token: token
-      )
-      @auth = CandidApiClient::Auth::AsyncClient.new(request_client: @async_request_client)
-      @billing_notes = CandidApiClient::BillingNotes::AsyncClient.new(request_client: @async_request_client)
-      @charge_capture_bundles = CandidApiClient::ChargeCaptureBundles::AsyncClient.new(request_client: @async_request_client)
-      @charge_capture = CandidApiClient::ChargeCapture::AsyncClient.new(request_client: @async_request_client)
-      @contracts = CandidApiClient::Contracts::AsyncClient.new(request_client: @async_request_client)
-      @credentialing = CandidApiClient::Credentialing::AsyncClient.new(request_client: @async_request_client)
-      @custom_schemas = CandidApiClient::CustomSchemas::AsyncClient.new(request_client: @async_request_client)
-      @eligibility = CandidApiClient::Eligibility::AsyncClient.new(request_client: @async_request_client)
-      @encounter_attachments = CandidApiClient::EncounterAttachments::AsyncClient.new(request_client: @async_request_client)
-      @encounter_providers = CandidApiClient::EncounterProviders::AsyncClient.new(request_client: @async_request_client)
-      @encounters = CandidApiClient::Encounters::AsyncClient.new(request_client: @async_request_client)
-      @expected_network_status = CandidApiClient::ExpectedNetworkStatus::AsyncClient.new(request_client: @async_request_client)
-      @exports = CandidApiClient::Exports::AsyncClient.new(request_client: @async_request_client)
-      @external_payment_account_config = CandidApiClient::ExternalPaymentAccountConfig::AsyncClient.new(request_client: @async_request_client)
-      @fee_schedules = CandidApiClient::FeeSchedules::AsyncClient.new(request_client: @async_request_client)
-      @guarantor = CandidApiClient::Guarantor::AsyncClient.new(request_client: @async_request_client)
-      @import_invoice = CandidApiClient::ImportInvoice::AsyncClient.new(request_client: @async_request_client)
-      @insurance_adjudications = CandidApiClient::InsuranceAdjudications::AsyncClient.new(request_client: @async_request_client)
-      @insurance_payments = CandidApiClient::InsurancePayments::AsyncClient.new(request_client: @async_request_client)
-      @insurance_refunds = CandidApiClient::InsuranceRefunds::AsyncClient.new(request_client: @async_request_client)
-      @medication_dispense = CandidApiClient::MedicationDispense::AsyncClient.new(request_client: @async_request_client)
-      @non_insurance_payer_payments = CandidApiClient::NonInsurancePayerPayments::AsyncClient.new(request_client: @async_request_client)
-      @non_insurance_payer_refunds = CandidApiClient::NonInsurancePayerRefunds::AsyncClient.new(request_client: @async_request_client)
-      @non_insurance_payers = CandidApiClient::NonInsurancePayers::AsyncClient.new(request_client: @async_request_client)
-      @organization_service_facilities = CandidApiClient::OrganizationServiceFacilities::AsyncClient.new(request_client: @async_request_client)
-      @organization_providers = CandidApiClient::OrganizationProviders::AsyncClient.new(request_client: @async_request_client)
-      @patient_payments = CandidApiClient::PatientPayments::AsyncClient.new(request_client: @async_request_client)
-      @patient_refunds = CandidApiClient::PatientRefunds::AsyncClient.new(request_client: @async_request_client)
-      @payer_plan_groups = CandidApiClient::PayerPlanGroups::AsyncClient.new(request_client: @async_request_client)
-      @payers = CandidApiClient::Payers::AsyncClient.new(request_client: @async_request_client)
-      @service_lines = CandidApiClient::ServiceLines::AsyncClient.new(request_client: @async_request_client)
-      @superbills = CandidApiClient::Superbills::AsyncClient.new(request_client: @async_request_client)
-      @tasks = CandidApiClient::Tasks::AsyncClient.new(request_client: @async_request_client)
-      @write_offs = CandidApiClient::WriteOffs::AsyncClient.new(request_client: @async_request_client)
-      @pre_encounter = CandidApiClient::PreEncounter::AsyncClient.new(request_client: @async_request_client)
-      @diagnoses = CandidApiClient::AsyncDiagnosesClient.new(request_client: @async_request_client)
-      @service_facility = CandidApiClient::AsyncServiceFacilityClient.new(request_client: @async_request_client)
+    # @return [CandidApiAuthOptions]
+    def initialize(token: nil, client_id: nil, client_secret: nil)
+       # @type [String]
+       @token = token
+       # @type [string]
+       @client_id = client_id
+       # @type [string]
+       @client_secret = client_secret
+     end
+
+
+    # @param environment [Environment]
+    def get_token(environment:)
+      unless @token.nil?
+        return @token
+      end
+
+      unauthed_client = Client.new(environment:environment)
+      response = unauthed_client.auth.v_2.get_token(request: {client_id: @client_id, client_secret: @client_secret})
+      return response.access_token
     end
   end
+
 end

data/lib/environment.rb

@@ -2,17 +2,7 @@
 
 module CandidApiClient
   class Environment
-    PRODUCTION = {
-      CandidApi: "https://api.joincandidhealth.com",
-      PreEncounter: "https://pre-api.joincandidhealth.com"
-    }.freeze
-    STAGING = {
-      CandidApi: "https://api-staging.joincandidhealth.com",
-      PreEncounter: "https://pre-api-staging.joincandidhealth.com"
-    }.freeze
-    CANDID_STAGING = {
-      CandidApi: "https://staging-api.joincandidhealth.com",
-      PreEncounter: "https://staging-pre-api.joincandidhealth.com"
-    }.freeze
+    PRODUCTION = "https://api.joincandidhealth.com"
+    STAGING = "https://api-staging.joincandidhealth.com"
   end
 end