candidhealth 0.0.0

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

@@ -0,0 +1,61 @@
+# 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
+
+          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
+
+          # 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
+
+          # Serialize an instance of RemittanceAdviceRemarkCode 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.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
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/yes_no_indicator/types/yes_no_indicator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CandidApiClient
+  module YesNoIndicator
+    module Types
+      class YesNoIndicator
+        YES = "YES"
+        NO = "NO"
+        UNKNOWN = "UNKNOWN"
+        NOT_APPLICABLE = "NOT_APPLICABLE"
+      end
+    end
+  end
+end

data/lib/candidhealth.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+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"
+
+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
+
+    # @param base_url [String]
+    # @param environment [CandidApiClient::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)
+    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
+
+    # @param base_url [String]
+    # @param environment [CandidApiClient::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::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)
+    end
+  end
+end

data/lib/core/file_utilities.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "faraday/multipart"
+require "mini_mime"
+
+module CandidApiClient
+  # Utility class for managing files.
+  class FileUtilities
+    # @param file_like [String, IO] The file to be uploaded, or a string path to the file.
+    # @return [Faraday::Multipart::FilePart]
+    def self.as_faraday_multipart(file_like:)
+      path = if file_like.is_a?(String)
+               file_like
+             else
+               file_like.path
+             end
+      mime_type = MiniMime.lookup_by_filename(path)
+      mime_type = if mime_type.nil?
+                    "application/octet-stream"
+                  else
+                    mime_type.content_type
+                  end
+      Faraday::Multipart::FilePart.new(file_like, mime_type)
+    end
+  end
+end

data/lib/core/oauth.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../requests"
+require_relative "../candidhealth/auth/default/client"
+require_relative "oauth"
+
+module CandidApiClient
+  class AccessToken
+    # @return [String]
+    attr_reader :access_token
+    # @return [Time]
+    attr_reader :expires_at
+
+    # @param access_token [String]
+    # @param expires_at [Time]
+    # @return [CandidApiClient::AccessToken]
+    def initialize(access_token:, expires_at: nil)
+      @access_token = access_token
+      @expires_at = expires_at
+    end
+  end
+
+  # Utility class for managing token refresh.
+  class OauthTokenProvider
+    # @return [String]
+    attr_reader :client_id
+    # @return [String]
+    attr_reader :client_secret
+    # @return [String]
+    attr_reader :auth_client
+
+    EXPIRY_BUFFER_MINUTES = 2
+
+    # @param client_id [String]
+    # @param client_secret [String]
+    # @param request_client [CandidApiClient::RequestClient]
+    # @return [CandidApiClient::OauthTokenProvider]
+    def initialize(client_id:, client_secret:, request_client:)
+      @client_id = client_id
+      @client_secret = client_secret
+      @auth_client = CandidApiClient::Auth::Default::DefaultClient.new(request_client: request_client)
+    end
+
+    # Returns a cached access token retrieved from the provided client credentials,
+    #  refreshing if necessary.
+    #
+    # @return [String]
+    def token
+      return @token.access_token if !@token.nil? && (@token.expires_at.nil? || @token.expires_at > Time.now)
+
+      @token = refresh_token
+      @token.access_token
+    end
+
+    # @return [CandidApiClient::AccessToken]
+    def refresh_token
+      token_response = @auth_client.get_token(client_id: @client_id, client_secret: @client_secret)
+      CandidApiClient::AccessToken.new(access_token: token_response.access_token,
+                                       expires_at: Time.now + token_response.expires_in - (EXPIRY_BUFFER_MINUTES * 60))
+    end
+  end
+end

data/lib/environment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/gemconfig.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CandidApiClient
+  module Gemconfig
+    VERSION = ""
+    AUTHORS = [""].freeze
+    EMAIL = ""
+    SUMMARY = ""
+    DESCRIPTION = ""
+    HOMEPAGE = "https://github.com/candidhealth/candid-ruby"
+    SOURCE_CODE_URI = "https://github.com/candidhealth/candid-ruby"
+    CHANGELOG_URI = "https://github.com/candidhealth/candid-ruby/blob/master/CHANGELOG.md"
+  end
+end