candidhealth 0.40.3 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b8c630a7776561f2352a1fc16254884d3558474c0d33ca8b75bddfc19c1b67
-  data.tar.gz: c6970b7ecc9c154cc20f565d7ca7563cb8f4c7beb658a037e7dcc67c5d76fd29
+  metadata.gz: e39a2483cd60af7d1b513f07999877000015c48ecf19bc049e87757dd7f3bead
+  data.tar.gz: 74202d0fbbf43b89cd8171e9dc89b8db54f076d4a548b873d110f291dba6ae5d
 SHA512:
-  metadata.gz: de4b0801486d89d2e73d6cf4a8b59e7d21a696f2c9bd654251e1db4044393f7594db0a4a31a8f796d17c6745fc88bf5a36585f3116b3276bc389f0a9ae4d88b4
-  data.tar.gz: ece09fc7e479f3ad88f17fd12c35a5f8b7cb49d1aadfe0a786df3a654135c2657a0911798278decdaa33c77a4cbf81ea46f8f309a9d87bc6d6e308cce8bb0b90
+  metadata.gz: 4b80689fff3b7578a6746e019c37d172648fd683dbabea32dc1748592de5d8c7b0a355ea42bb833254d11b8ffe9833f5bae37d1b1878c30458c54ddf3b622fe5
+  data.tar.gz: bd746740f98eba1ed015b656213ec62664e50d7dcf8f4a5a225d638c3f0d5eec6bc7bba051dfea17811a65f374a03cabfa1dbf77be3c3e06b2cfe7cda630f959

data/lib/candidhealth/charge_capture/v_1/client.rb

@@ -8,6 +8,7 @@ require_relative "types/charge_capture"
 require_relative "types/charge_capture_sort_field"
 require_relative "../../commons/types/sort_direction"
 require_relative "types/charge_capture_page"
+require_relative "types/charge_capture_post_billed_change"
 require "async"
 
 module CandidApiClient
@@ -719,6 +720,31 @@ module CandidApiClient
           end
           CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePage.from_json(json_object: response.body)
         end
+
+        # @param charge_capture_change_id [String]
+        # @param resolved [Boolean] Whether the change has been resolved. If true, the change will be marked as
+        #  resolved.
+        #  If false, the change will be marked as unresolved.
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.charge_capture.v_1.update_post_billed_change(charge_capture_change_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", resolved: true)
+        def update_post_billed_change(charge_capture_change_id:, resolved:, request_options: nil)
+          response = @request_client.conn.patch 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_options&.additional_body_parameters || {}), resolved: resolved }.compact
+            req.url "#{@request_client.get_url(environment: CandidApi,
+                                               request_options: request_options)}/api/charge_captures/v1/changes/#{charge_capture_change_id}"
+          end
+          CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange.from_json(json_object: response.body)
+        end
       end
 
       class AsyncV1Client
@@ -1437,6 +1463,33 @@ module CandidApiClient
             CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePage.from_json(json_object: response.body)
           end
         end
+
+        # @param charge_capture_change_id [String]
+        # @param resolved [Boolean] Whether the change has been resolved. If true, the change will be marked as
+        #  resolved.
+        #  If false, the change will be marked as unresolved.
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.charge_capture.v_1.update_post_billed_change(charge_capture_change_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", resolved: true)
+        def update_post_billed_change(charge_capture_change_id:, resolved:, request_options: nil)
+          Async do
+            response = @request_client.conn.patch 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_options&.additional_body_parameters || {}), resolved: resolved }.compact
+              req.url "#{@request_client.get_url(environment: CandidApi,
+                                                 request_options: request_options)}/api/charge_captures/v1/changes/#{charge_capture_change_id}"
+            end
+            CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange.from_json(json_object: response.body)
+          end
+        end
       end
     end
   end

data/lib/candidhealth/charge_capture/v_1/types/charge_capture.rb

@@ -3,6 +3,7 @@
 require_relative "charge_capture_status"
 require_relative "charge_capture_data"
 require "date"
+require_relative "charge_capture_error"
 require_relative "charge_capture_post_billed_change"
 require "ostruct"
 require "json"
@@ -27,6 +28,8 @@ module CandidApiClient
           # @return [Date] Date formatted as YYYY-MM-DD; eg: 2019-08-24.
           #  This date must be the local date in the timezone where the service occurred.
           attr_reader :date_of_service
+          # @return [CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError]
+          attr_reader :error
           # @return [Array<CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange>]
           attr_reader :updates
           # @return [OpenStruct] Additional properties unmapped to the current class definition
@@ -45,11 +48,12 @@ module CandidApiClient
           # @param ehr_source_url [String]
           # @param date_of_service [Date] Date formatted as YYYY-MM-DD; eg: 2019-08-24.
           #  This date must be the local date in the timezone where the service occurred.
+          # @param error [CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError]
           # @param updates [Array<CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange>]
           # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
           # @return [CandidApiClient::ChargeCapture::V1::Types::ChargeCapture]
           def initialize(id:, status:, charge_capture_data:, patient_external_id:, charge_external_id:, updates:,
-                         ehr_source_url: OMIT, date_of_service: OMIT, additional_properties: nil)
+                         ehr_source_url: OMIT, date_of_service: OMIT, error: OMIT, additional_properties: nil)
             @id = id
             @status = status
             @charge_capture_data = charge_capture_data
@@ -57,6 +61,7 @@ module CandidApiClient
             @charge_external_id = charge_external_id
             @ehr_source_url = ehr_source_url if ehr_source_url != OMIT
             @date_of_service = date_of_service if date_of_service != OMIT
+            @error = error if error != OMIT
             @updates = updates
             @additional_properties = additional_properties
             @_field_set = {
@@ -67,6 +72,7 @@ module CandidApiClient
               "charge_external_id": charge_external_id,
               "ehr_source_url": ehr_source_url,
               "date_of_service": date_of_service,
+              "error": error,
               "updates": updates
             }.reject do |_k, v|
               v == OMIT
@@ -92,6 +98,12 @@ module CandidApiClient
             charge_external_id = struct["charge_external_id"]
             ehr_source_url = struct["ehr_source_url"]
             date_of_service = (Date.parse(parsed_json["date_of_service"]) unless parsed_json["date_of_service"].nil?)
+            if parsed_json["error"].nil?
+              error = nil
+            else
+              error = parsed_json["error"].to_json
+              error = CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError.from_json(json_object: error)
+            end
             updates = parsed_json["updates"]&.map do |item|
               item = item.to_json
               CandidApiClient::ChargeCapture::V1::Types::ChargeCapturePostBilledChange.from_json(json_object: item)
@@ -104,6 +116,7 @@ module CandidApiClient
               charge_external_id: charge_external_id,
               ehr_source_url: ehr_source_url,
               date_of_service: date_of_service,
+              error: error,
               updates: updates,
               additional_properties: struct
             )
@@ -130,6 +143,7 @@ module CandidApiClient
             obj.charge_external_id.is_a?(String) != false || raise("Passed value for field obj.charge_external_id is not the expected type, validation failed.")
             obj.ehr_source_url&.is_a?(String) != false || raise("Passed value for field obj.ehr_source_url is not the expected type, validation failed.")
             obj.date_of_service&.is_a?(Date) != false || raise("Passed value for field obj.date_of_service is not the expected type, validation failed.")
+            obj.error.nil? || CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError.validate_raw(obj: obj.error)
             obj.updates.is_a?(Array) != false || raise("Passed value for field obj.updates is not the expected type, validation failed.")
           end
         end

data/lib/candidhealth/{charge_capture_bundles/v_1/types/charge_bundle_error.rb → charge_capture/v_1/types/charge_capture_error.rb}

@@ -4,10 +4,10 @@ require "ostruct"
 require "json"
 
 module CandidApiClient
-  module ChargeCaptureBundles
+  module ChargeCapture
     module V1
       module Types
-        class ChargeBundleError
+        class ChargeCaptureError
           # @return [String]
           attr_reader :id
           # @return [String] The underlying Charge Capture that this error object references.
@@ -44,7 +44,7 @@ module CandidApiClient
           #  is not present but marked as required, or otherwise in error.
           # @param bundle_id [String] The ID of the ChargeCaptureBundle associated with this Error.
           # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-          # @return [CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeBundleError]
+          # @return [CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError]
           def initialize(id:, message:, bundle_id:, charge_capture_id: OMIT, field_in_error: OMIT,
                          additional_properties: nil)
             @id = id
@@ -64,10 +64,10 @@ module CandidApiClient
             end
           end
 
-          # Deserialize a JSON object to an instance of ChargeBundleError
+          # Deserialize a JSON object to an instance of ChargeCaptureError
           #
           # @param json_object [String]
-          # @return [CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeBundleError]
+          # @return [CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError]
           def self.from_json(json_object:)
             struct = JSON.parse(json_object, object_class: OpenStruct)
             id = struct["id"]
@@ -85,7 +85,7 @@ module CandidApiClient
             )
           end
 
-          # Serialize an instance of ChargeBundleError to a JSON object
+          # Serialize an instance of ChargeCaptureError to a JSON object
           #
           # @return [String]
           def to_json(*_args)

data/lib/candidhealth/charge_capture_bundles/v_1/client.rb

@@ -60,7 +60,7 @@ module CandidApiClient
           **(request_options&.additional_headers || {})
             }.compact
             req.url "#{@request_client.get_url(environment: CandidApi,
-                                               request_options: request_options)}/api/charge_capture_bundle/v1/summary"
+                                               request_options: request_options)}/api/charge_capture_bundle/v1/all/summary"
           end
           CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeCaptureBundleSummary.from_json(json_object: response.body)
         end
@@ -197,7 +197,7 @@ module CandidApiClient
             **(request_options&.additional_headers || {})
               }.compact
               req.url "#{@request_client.get_url(environment: CandidApi,
-                                                 request_options: request_options)}/api/charge_capture_bundle/v1/summary"
+                                                 request_options: request_options)}/api/charge_capture_bundle/v1/all/summary"
             end
             CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeCaptureBundleSummary.from_json(json_object: response.body)
           end

data/lib/candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle.rb

@@ -2,7 +2,7 @@
 
 require_relative "charge_capture_bundle_status"
 require_relative "../../../charge_capture/v_1/types/charge_capture"
-require_relative "charge_bundle_error"
+require_relative "../../../charge_capture/v_1/types/charge_capture_error"
 require "ostruct"
 require "json"
 
@@ -20,7 +20,7 @@ module CandidApiClient
           attr_reader :status
           # @return [Array<CandidApiClient::ChargeCapture::V1::Types::ChargeCapture>] All the underlying ChargeCaptures that are present in a ChargeCaptureBundle.
           attr_reader :charge_captures
-          # @return [Array<CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeBundleError>] All errors that were found when the bundle was attempted to be created.
+          # @return [Array<CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError>] All errors that were found when the bundle was attempted to be created.
           #  Errors can correspond to the Bundle as a whole or specific underlying Charge
           #  Captures.
           attr_reader :errors
@@ -37,7 +37,7 @@ module CandidApiClient
           # @param status [CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeCaptureBundleStatus] Status of the Bundle, Successful means that the Bundle created a corresponding
           #  Claim
           # @param charge_captures [Array<CandidApiClient::ChargeCapture::V1::Types::ChargeCapture>] All the underlying ChargeCaptures that are present in a ChargeCaptureBundle.
-          # @param errors [Array<CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeBundleError>] All errors that were found when the bundle was attempted to be created.
+          # @param errors [Array<CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError>] All errors that were found when the bundle was attempted to be created.
           #  Errors can correspond to the Bundle as a whole or specific underlying Charge
           #  Captures.
           # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
@@ -77,7 +77,7 @@ module CandidApiClient
             end
             errors = parsed_json["errors"]&.map do |item|
               item = item.to_json
-              CandidApiClient::ChargeCaptureBundles::V1::Types::ChargeBundleError.from_json(json_object: item)
+              CandidApiClient::ChargeCapture::V1::Types::ChargeCaptureError.from_json(json_object: item)
             end
             new(
               id: id,

data/lib/candidhealth/payer_plan_groups/client.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../requests"
+require_relative "v_1/client"
+
+module CandidApiClient
+  module PayerPlanGroups
+    class Client
+      # @return [CandidApiClient::PayerPlanGroups::V1::V1Client]
+      attr_reader :v_1
+
+      # @param request_client [CandidApiClient::RequestClient]
+      # @return [CandidApiClient::PayerPlanGroups::Client]
+      def initialize(request_client:)
+        @v_1 = CandidApiClient::PayerPlanGroups::V1::V1Client.new(request_client: request_client)
+      end
+    end
+
+    class AsyncClient
+      # @return [CandidApiClient::PayerPlanGroups::V1::AsyncV1Client]
+      attr_reader :v_1
+
+      # @param request_client [CandidApiClient::AsyncRequestClient]
+      # @return [CandidApiClient::PayerPlanGroups::AsyncClient]
+      def initialize(request_client:)
+        @v_1 = CandidApiClient::PayerPlanGroups::V1::AsyncV1Client.new(request_client: request_client)
+      end
+    end
+  end
+end

data/lib/candidhealth/payer_plan_groups/v_1/client.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "../../commons/types/source_of_payment_code"
+require_relative "types/payer_plan_group_sort_field"
+require_relative "../../commons/types/sort_direction"
+require_relative "types/payer_plan_group_page"
+require_relative "types/payer_plan_group"
+require_relative "types/mutable_payer_plan_group"
+require "async"
+
+module CandidApiClient
+  module PayerPlanGroups
+    module V1
+      class V1Client
+        # @return [CandidApiClient::RequestClient]
+        attr_reader :request_client
+
+        # @param request_client [CandidApiClient::RequestClient]
+        # @return [CandidApiClient::PayerPlanGroups::V1::V1Client]
+        def initialize(request_client:)
+          @request_client = request_client
+        end
+
+        # Returns all payer plan groups matching filter criteria.
+        #
+        # @param plan_group_name [String]
+        # @param payer_uuid [String]
+        # @param payer_id [String]
+        # @param plan_type [CandidApiClient::Commons::Types::SourceOfPaymentCode]
+        # @param is_active [Boolean]
+        # @param payer_plan_group_id [String]
+        # @param limit [Integer] Defaults to 100. Cannot exc
+        # @param sort_by_similarity [String] If this property is passed, the results will be ordered by those that contain a
+        #  payer_id, payer_name, plan_group_name, or
+        #  payer_address most similar to the value passed. This will take precedence over
+        #  the sort and sort_direction properties. This
+        #  will always sort in order of most similar to least similar.
+        # @param sort [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupSortField] Defaults to plan_group_name. If sort_by_similarity is passed, that sort will
+        #  takes precedence over this property.
+        # @param sort_direction [CandidApiClient::Commons::Types::SortDirection] Sort direction. Defaults to ascending order if not provided.
+        # @param page_token [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupPage]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.get_multi(
+        #    plan_group_name: "string",
+        #    payer_uuid: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32",
+        #    payer_id: "string",
+        #    plan_type: SELF_PAY,
+        #    is_active: true,
+        #    payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32",
+        #    limit: 1,
+        #    sort_by_similarity: "string",
+        #    sort: PLAN_GROUP_NAME,
+        #    sort_direction: ASC,
+        #    page_token: "eyJ0b2tlbiI6IjEiLCJwYWdlX3Rva2VuIjoiMiJ9"
+        #  )
+        def get_multi(plan_group_name: nil, payer_uuid: nil, payer_id: nil, plan_type: nil, is_active: nil,
+                      payer_plan_group_id: nil, limit: nil, sort_by_similarity: nil, sort: nil, sort_direction: nil, page_token: nil, 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.params = {
+              **(request_options&.additional_query_parameters || {}),
+              "plan_group_name": plan_group_name,
+              "payer_uuid": payer_uuid,
+              "payer_id": payer_id,
+              "plan_type": plan_type,
+              "is_active": is_active,
+              "payer_plan_group_id": payer_plan_group_id,
+              "limit": limit,
+              "sort_by_similarity": sort_by_similarity,
+              "sort": sort,
+              "sort_direction": sort_direction,
+              "page_token": page_token
+            }.compact
+            req.url "#{@request_client.get_url(environment: CandidApi,
+                                               request_options: request_options)}/api/payer-plan-groups/v1"
+          end
+          CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupPage.from_json(json_object: response.body)
+        end
+
+        # Return a plan group with a given ID.
+        #
+        # @param payer_plan_group_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.get(payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def get(payer_plan_group_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: CandidApi,
+                                               request_options: request_options)}/api/payer-plan-groups/v1/#{payer_plan_group_id}"
+          end
+          CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+        end
+
+        # Create a payer plan group
+        #
+        # @param request [Hash] Request of type CandidApiClient::PayerPlanGroups::V1::Types::MutablePayerPlanGroup, as a Hash
+        #   * :plan_group_name (String)
+        #   * :payer_uuid (String)
+        #   * :plan_type (CandidApiClient::Commons::Types::SourceOfPaymentCode)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.create(request: { plan_group_name: "string", payer_uuid: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", plan_type: SELF_PAY })
+        def create(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: CandidApi,
+                                               request_options: request_options)}/api/payer-plan-groups/v1"
+          end
+          CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+        end
+
+        # Update any of the fields on a payer plan group
+        #
+        # @param payer_plan_group_id [String]
+        # @param request [Hash] Request of type CandidApiClient::PayerPlanGroups::V1::Types::MutablePayerPlanGroup, as a Hash
+        #   * :plan_group_name (String)
+        #   * :payer_uuid (String)
+        #   * :plan_type (CandidApiClient::Commons::Types::SourceOfPaymentCode)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.update(payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", request: { plan_group_name: "string", payer_uuid: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", plan_type: SELF_PAY })
+        def update(payer_plan_group_id:, request:, request_options: nil)
+          response = @request_client.conn.put 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: CandidApi,
+                                               request_options: request_options)}/api/payer-plan-groups/v1/#{payer_plan_group_id}"
+          end
+          CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+        end
+
+        # Marks the payer plan group as deactivated
+        #
+        # @param payer_plan_group_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.deactivate(payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def deactivate(payer_plan_group_id:, request_options: nil)
+          response = @request_client.conn.patch 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: CandidApi,
+                                               request_options: request_options)}/api/payer-plan-groups/v1/#{payer_plan_group_id}"
+          end
+          CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+        end
+      end
+
+      class AsyncV1Client
+        # @return [CandidApiClient::AsyncRequestClient]
+        attr_reader :request_client
+
+        # @param request_client [CandidApiClient::AsyncRequestClient]
+        # @return [CandidApiClient::PayerPlanGroups::V1::AsyncV1Client]
+        def initialize(request_client:)
+          @request_client = request_client
+        end
+
+        # Returns all payer plan groups matching filter criteria.
+        #
+        # @param plan_group_name [String]
+        # @param payer_uuid [String]
+        # @param payer_id [String]
+        # @param plan_type [CandidApiClient::Commons::Types::SourceOfPaymentCode]
+        # @param is_active [Boolean]
+        # @param payer_plan_group_id [String]
+        # @param limit [Integer] Defaults to 100. Cannot exc
+        # @param sort_by_similarity [String] If this property is passed, the results will be ordered by those that contain a
+        #  payer_id, payer_name, plan_group_name, or
+        #  payer_address most similar to the value passed. This will take precedence over
+        #  the sort and sort_direction properties. This
+        #  will always sort in order of most similar to least similar.
+        # @param sort [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupSortField] Defaults to plan_group_name. If sort_by_similarity is passed, that sort will
+        #  takes precedence over this property.
+        # @param sort_direction [CandidApiClient::Commons::Types::SortDirection] Sort direction. Defaults to ascending order if not provided.
+        # @param page_token [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupPage]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.get_multi(
+        #    plan_group_name: "string",
+        #    payer_uuid: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32",
+        #    payer_id: "string",
+        #    plan_type: SELF_PAY,
+        #    is_active: true,
+        #    payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32",
+        #    limit: 1,
+        #    sort_by_similarity: "string",
+        #    sort: PLAN_GROUP_NAME,
+        #    sort_direction: ASC,
+        #    page_token: "eyJ0b2tlbiI6IjEiLCJwYWdlX3Rva2VuIjoiMiJ9"
+        #  )
+        def get_multi(plan_group_name: nil, payer_uuid: nil, payer_id: nil, plan_type: nil, is_active: nil,
+                      payer_plan_group_id: nil, limit: nil, sort_by_similarity: nil, sort: nil, sort_direction: nil, page_token: nil, 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.params = {
+                **(request_options&.additional_query_parameters || {}),
+                "plan_group_name": plan_group_name,
+                "payer_uuid": payer_uuid,
+                "payer_id": payer_id,
+                "plan_type": plan_type,
+                "is_active": is_active,
+                "payer_plan_group_id": payer_plan_group_id,
+                "limit": limit,
+                "sort_by_similarity": sort_by_similarity,
+                "sort": sort,
+                "sort_direction": sort_direction,
+                "page_token": page_token
+              }.compact
+              req.url "#{@request_client.get_url(environment: CandidApi,
+                                                 request_options: request_options)}/api/payer-plan-groups/v1"
+            end
+            CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupPage.from_json(json_object: response.body)
+          end
+        end
+
+        # Return a plan group with a given ID.
+        #
+        # @param payer_plan_group_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.get(payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def get(payer_plan_group_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: CandidApi,
+                                                 request_options: request_options)}/api/payer-plan-groups/v1/#{payer_plan_group_id}"
+            end
+            CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+          end
+        end
+
+        # Create a payer plan group
+        #
+        # @param request [Hash] Request of type CandidApiClient::PayerPlanGroups::V1::Types::MutablePayerPlanGroup, as a Hash
+        #   * :plan_group_name (String)
+        #   * :payer_uuid (String)
+        #   * :plan_type (CandidApiClient::Commons::Types::SourceOfPaymentCode)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.create(request: { plan_group_name: "string", payer_uuid: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", plan_type: SELF_PAY })
+        def create(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: CandidApi,
+                                                 request_options: request_options)}/api/payer-plan-groups/v1"
+            end
+            CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+          end
+        end
+
+        # Update any of the fields on a payer plan group
+        #
+        # @param payer_plan_group_id [String]
+        # @param request [Hash] Request of type CandidApiClient::PayerPlanGroups::V1::Types::MutablePayerPlanGroup, as a Hash
+        #   * :plan_group_name (String)
+        #   * :payer_uuid (String)
+        #   * :plan_type (CandidApiClient::Commons::Types::SourceOfPaymentCode)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.update(payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", request: { plan_group_name: "string", payer_uuid: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", plan_type: SELF_PAY })
+        def update(payer_plan_group_id:, request:, request_options: nil)
+          Async do
+            response = @request_client.conn.put 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: CandidApi,
+                                                 request_options: request_options)}/api/payer-plan-groups/v1/#{payer_plan_group_id}"
+            end
+            CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+          end
+        end
+
+        # Marks the payer plan group as deactivated
+        #
+        # @param payer_plan_group_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.payer_plan_groups.v_1.deactivate(payer_plan_group_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def deactivate(payer_plan_group_id:, request_options: nil)
+          Async do
+            response = @request_client.conn.patch 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: CandidApi,
+                                                 request_options: request_options)}/api/payer-plan-groups/v1/#{payer_plan_group_id}"
+            end
+            CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: response.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/payer_plan_groups/v_1/types/mutable_payer_plan_group.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../../../commons/types/source_of_payment_code"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PayerPlanGroups
+    module V1
+      module Types
+        class MutablePayerPlanGroup
+          # @return [String]
+          attr_reader :plan_group_name
+          # @return [String]
+          attr_reader :payer_uuid
+          # @return [CandidApiClient::Commons::Types::SourceOfPaymentCode]
+          attr_reader :plan_type
+          # @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 plan_group_name [String]
+          # @param payer_uuid [String]
+          # @param plan_type [CandidApiClient::Commons::Types::SourceOfPaymentCode]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::MutablePayerPlanGroup]
+          def initialize(plan_group_name:, payer_uuid:, plan_type:, additional_properties: nil)
+            @plan_group_name = plan_group_name
+            @payer_uuid = payer_uuid
+            @plan_type = plan_type
+            @additional_properties = additional_properties
+            @_field_set = { "plan_group_name": plan_group_name, "payer_uuid": payer_uuid, "plan_type": plan_type }
+          end
+
+          # Deserialize a JSON object to an instance of MutablePayerPlanGroup
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::MutablePayerPlanGroup]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            plan_group_name = struct["plan_group_name"]
+            payer_uuid = struct["payer_uuid"]
+            plan_type = struct["plan_type"]
+            new(
+              plan_group_name: plan_group_name,
+              payer_uuid: payer_uuid,
+              plan_type: plan_type,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of MutablePayerPlanGroup 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.plan_group_name.is_a?(String) != false || raise("Passed value for field obj.plan_group_name is not the expected type, validation failed.")
+            obj.payer_uuid.is_a?(String) != false || raise("Passed value for field obj.payer_uuid is not the expected type, validation failed.")
+            obj.plan_type.is_a?(CandidApiClient::Commons::Types::SourceOfPaymentCode) != false || raise("Passed value for field obj.plan_type is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../../../payers/v_3/types/payer"
+require_relative "../../../commons/types/source_of_payment_code"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PayerPlanGroups
+    module V1
+      module Types
+        class PayerPlanGroup
+          # @return [String]
+          attr_reader :payer_plan_group_id
+          # @return [CandidApiClient::Payers::V3::Types::Payer]
+          attr_reader :payer
+          # @return [Boolean]
+          attr_reader :is_active
+          # @return [String]
+          attr_reader :plan_group_name
+          # @return [String]
+          attr_reader :payer_uuid
+          # @return [CandidApiClient::Commons::Types::SourceOfPaymentCode]
+          attr_reader :plan_type
+          # @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 payer_plan_group_id [String]
+          # @param payer [CandidApiClient::Payers::V3::Types::Payer]
+          # @param is_active [Boolean]
+          # @param plan_group_name [String]
+          # @param payer_uuid [String]
+          # @param plan_type [CandidApiClient::Commons::Types::SourceOfPaymentCode]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+          def initialize(payer_plan_group_id:, payer:, is_active:, plan_group_name:, payer_uuid:, plan_type:,
+                         additional_properties: nil)
+            @payer_plan_group_id = payer_plan_group_id
+            @payer = payer
+            @is_active = is_active
+            @plan_group_name = plan_group_name
+            @payer_uuid = payer_uuid
+            @plan_type = plan_type
+            @additional_properties = additional_properties
+            @_field_set = {
+              "payer_plan_group_id": payer_plan_group_id,
+              "payer": payer,
+              "is_active": is_active,
+              "plan_group_name": plan_group_name,
+              "payer_uuid": payer_uuid,
+              "plan_type": plan_type
+            }
+          end
+
+          # Deserialize a JSON object to an instance of PayerPlanGroup
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            parsed_json = JSON.parse(json_object)
+            payer_plan_group_id = struct["payer_plan_group_id"]
+            if parsed_json["payer"].nil?
+              payer = nil
+            else
+              payer = parsed_json["payer"].to_json
+              payer = CandidApiClient::Payers::V3::Types::Payer.from_json(json_object: payer)
+            end
+            is_active = struct["is_active"]
+            plan_group_name = struct["plan_group_name"]
+            payer_uuid = struct["payer_uuid"]
+            plan_type = struct["plan_type"]
+            new(
+              payer_plan_group_id: payer_plan_group_id,
+              payer: payer,
+              is_active: is_active,
+              plan_group_name: plan_group_name,
+              payer_uuid: payer_uuid,
+              plan_type: plan_type,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of PayerPlanGroup 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.payer_plan_group_id.is_a?(String) != false || raise("Passed value for field obj.payer_plan_group_id is not the expected type, validation failed.")
+            CandidApiClient::Payers::V3::Types::Payer.validate_raw(obj: obj.payer)
+            obj.is_active.is_a?(Boolean) != false || raise("Passed value for field obj.is_active is not the expected type, validation failed.")
+            obj.plan_group_name.is_a?(String) != false || raise("Passed value for field obj.plan_group_name is not the expected type, validation failed.")
+            obj.payer_uuid.is_a?(String) != false || raise("Passed value for field obj.payer_uuid is not the expected type, validation failed.")
+            obj.plan_type.is_a?(CandidApiClient::Commons::Types::SourceOfPaymentCode) != false || raise("Passed value for field obj.plan_type is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group_already_exists_error.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PayerPlanGroups
+    module V1
+      module Types
+        class PayerPlanGroupAlreadyExistsError
+          # @return [String]
+          attr_reader :message
+          # @return [String]
+          attr_reader :id
+          # @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 message [String]
+          # @param id [String]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupAlreadyExistsError]
+          def initialize(message:, id:, additional_properties: nil)
+            @message = message
+            @id = id
+            @additional_properties = additional_properties
+            @_field_set = { "message": message, "id": id }
+          end
+
+          # Deserialize a JSON object to an instance of PayerPlanGroupAlreadyExistsError
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupAlreadyExistsError]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            message = struct["message"]
+            id = struct["id"]
+            new(
+              message: message,
+              id: id,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of PayerPlanGroupAlreadyExistsError 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.message.is_a?(String) != false || raise("Passed value for field obj.message is not the expected type, validation failed.")
+            obj.id.is_a?(String) != false || raise("Passed value for field obj.id is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group_page.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "payer_plan_group"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module PayerPlanGroups
+    module V1
+      module Types
+        class PayerPlanGroupPage
+          # @return [Array<CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup>]
+          attr_reader :items
+          # @return [String]
+          attr_reader :prev_page_token
+          # @return [String]
+          attr_reader :next_page_token
+          # @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 items [Array<CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup>]
+          # @param prev_page_token [String]
+          # @param next_page_token [String]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupPage]
+          def initialize(items:, prev_page_token: OMIT, next_page_token: OMIT, additional_properties: nil)
+            @items = items
+            @prev_page_token = prev_page_token if prev_page_token != OMIT
+            @next_page_token = next_page_token if next_page_token != OMIT
+            @additional_properties = additional_properties
+            @_field_set = {
+              "items": items,
+              "prev_page_token": prev_page_token,
+              "next_page_token": next_page_token
+            }.reject do |_k, v|
+              v == OMIT
+            end
+          end
+
+          # Deserialize a JSON object to an instance of PayerPlanGroupPage
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroupPage]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            parsed_json = JSON.parse(json_object)
+            items = parsed_json["items"]&.map do |item|
+              item = item.to_json
+              CandidApiClient::PayerPlanGroups::V1::Types::PayerPlanGroup.from_json(json_object: item)
+            end
+            prev_page_token = struct["prev_page_token"]
+            next_page_token = struct["next_page_token"]
+            new(
+              items: items,
+              prev_page_token: prev_page_token,
+              next_page_token: next_page_token,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of PayerPlanGroupPage 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.items.is_a?(Array) != false || raise("Passed value for field obj.items is not the expected type, validation failed.")
+            obj.prev_page_token&.is_a?(String) != false || raise("Passed value for field obj.prev_page_token is not the expected type, validation failed.")
+            obj.next_page_token&.is_a?(String) != false || raise("Passed value for field obj.next_page_token is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group_sort_field.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CandidApiClient
+  module PayerPlanGroups
+    module V1
+      module Types
+        class PayerPlanGroupSortField
+          PLAN_GROUP_NAME = "plan_group_name"
+          PLAN_TYPE = "plan_type"
+          CREATED_AT = "created_at"
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/tasks/commons/types/task_category.rb

@@ -46,6 +46,7 @@ module CandidApiClient
           HELD_BY_CUSTOMER = "held_by_customer"
           PENDING_MANUAL_REMIT_POSTING = "pending_manual_remit_posting"
           INCORRECT_REFERRING_PROVIDER_INFO = "incorrect_referring_provider_info"
+          PAYER_CONFIGURATION_ERROR = "payer_configuration_error"
         end
       end
     end

data/lib/candidhealth.rb

@@ -31,6 +31,7 @@ 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/tasks/client"
@@ -95,6 +96,8 @@ module CandidApiClient
     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]
@@ -163,6 +166,7 @@ module CandidApiClient
       @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)
       @tasks = CandidApiClient::Tasks::Client.new(request_client: @request_client)
@@ -228,6 +232,8 @@ module CandidApiClient
     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]
@@ -296,6 +302,7 @@ module CandidApiClient
       @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)
       @tasks = CandidApiClient::Tasks::AsyncClient.new(request_client: @async_request_client)

data/lib/requests.rb

@@ -43,7 +43,7 @@ module CandidApiClient
 
     # @return [Hash{String => String}]
     def get_headers
-      headers = { "X-Fern-Language": "Ruby", "X-Fern-SDK-Name": "candidhealth", "X-Fern-SDK-Version": "0.40.3" }
+      headers = { "X-Fern-Language": "Ruby", "X-Fern-SDK-Name": "candidhealth", "X-Fern-SDK-Version": "0.41.0" }
       headers["Authorization"] = ((@token.is_a? Method) ? @token.call : @token) unless token.nil?
       headers
     end
@@ -87,7 +87,7 @@ module CandidApiClient
 
     # @return [Hash{String => String}]
     def get_headers
-      headers = { "X-Fern-Language": "Ruby", "X-Fern-SDK-Name": "candidhealth", "X-Fern-SDK-Version": "0.40.3" }
+      headers = { "X-Fern-Language": "Ruby", "X-Fern-SDK-Name": "candidhealth", "X-Fern-SDK-Version": "0.41.0" }
       headers["Authorization"] = ((@token.is_a? Method) ? @token.call : @token) unless token.nil?
       headers
     end

data/lib/types_export.rb

@@ -7,12 +7,12 @@ require_relative "candidhealth/billing_notes/v_2/types/billing_note"
 require_relative "candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle_page"
 require_relative "candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle"
 require_relative "candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle_summary"
-require_relative "candidhealth/charge_capture_bundles/v_1/types/charge_bundle_error"
 require_relative "candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle_status"
 require_relative "candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle_sort_field"
 require_relative "candidhealth/charge_capture/v_1/types/charge_capture_page"
 require_relative "candidhealth/charge_capture/v_1/types/charge_capture"
 require_relative "candidhealth/charge_capture/v_1/types/charge_capture_data"
+require_relative "candidhealth/charge_capture/v_1/types/charge_capture_error"
 require_relative "candidhealth/charge_capture/v_1/types/charge_capture_sort_field"
 require_relative "candidhealth/charge_capture/v_1/types/charge_capture_status"
 require_relative "candidhealth/charge_capture/v_1/types/charge_capture_post_billed_change"
@@ -245,6 +245,11 @@ require_relative "candidhealth/patient_payments/v_4/types/patient_payment_sort_f
 require_relative "candidhealth/patient_refunds/v_1/types/patient_refund"
 require_relative "candidhealth/patient_refunds/v_1/types/patient_refunds_page"
 require_relative "candidhealth/patient_refunds/v_1/types/patient_refund_sort_field"
+require_relative "candidhealth/payer_plan_groups/v_1/types/mutable_payer_plan_group"
+require_relative "candidhealth/payer_plan_groups/v_1/types/payer_plan_group"
+require_relative "candidhealth/payer_plan_groups/v_1/types/payer_plan_group_page"
+require_relative "candidhealth/payer_plan_groups/v_1/types/payer_plan_group_sort_field"
+require_relative "candidhealth/payer_plan_groups/v_1/types/payer_plan_group_already_exists_error"
 require_relative "candidhealth/payers/v_3/types/payer_page"
 require_relative "candidhealth/payers/v_3/types/payer"
 require_relative "candidhealth/payers/v_3/types/payer_info"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: candidhealth
 version: !ruby/object:Gem::Version
-  version: 0.40.3
+  version: 0.41.0
 platform: ruby
 authors:
 - ''
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-10 00:00:00.000000000 Z
+date: 2025-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http-faraday
@@ -109,13 +109,13 @@ files:
 - lib/candidhealth/charge_capture/v_1/client.rb
 - lib/candidhealth/charge_capture/v_1/types/charge_capture.rb
 - lib/candidhealth/charge_capture/v_1/types/charge_capture_data.rb
+- lib/candidhealth/charge_capture/v_1/types/charge_capture_error.rb
 - lib/candidhealth/charge_capture/v_1/types/charge_capture_page.rb
 - lib/candidhealth/charge_capture/v_1/types/charge_capture_post_billed_change.rb
 - lib/candidhealth/charge_capture/v_1/types/charge_capture_sort_field.rb
 - lib/candidhealth/charge_capture/v_1/types/charge_capture_status.rb
 - lib/candidhealth/charge_capture_bundles/client.rb
 - lib/candidhealth/charge_capture_bundles/v_1/client.rb
-- lib/candidhealth/charge_capture_bundles/v_1/types/charge_bundle_error.rb
 - lib/candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle.rb
 - lib/candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle_page.rb
 - lib/candidhealth/charge_capture_bundles/v_1/types/charge_capture_bundle_sort_field.rb
@@ -487,6 +487,13 @@ files:
 - lib/candidhealth/patient_refunds/v_1/types/patient_refund.rb
 - lib/candidhealth/patient_refunds/v_1/types/patient_refund_sort_field.rb
 - lib/candidhealth/patient_refunds/v_1/types/patient_refunds_page.rb
+- lib/candidhealth/payer_plan_groups/client.rb
+- lib/candidhealth/payer_plan_groups/v_1/client.rb
+- lib/candidhealth/payer_plan_groups/v_1/types/mutable_payer_plan_group.rb
+- lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group.rb
+- lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group_already_exists_error.rb
+- lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group_page.rb
+- lib/candidhealth/payer_plan_groups/v_1/types/payer_plan_group_sort_field.rb
 - lib/candidhealth/payers/client.rb
 - lib/candidhealth/payers/v_3/client.rb
 - lib/candidhealth/payers/v_3/types/payer.rb