candidhealth 0.0.0

data/lib/candidhealth/tasks/v_3/client.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "types/task_actions"
+require_relative "../commons/types/task_status"
+require_relative "../commons/types/task_type"
+require "date"
+require_relative "types/task_sort_options"
+require_relative "types/task_page"
+require_relative "types/task"
+require_relative "types/task_create_v_3"
+require_relative "types/task_update_v_3"
+require "async"
+
+module CandidApiClient
+  module Tasks
+    module V3
+      class V3Client
+        # @return [CandidApiClient::RequestClient]
+        attr_reader :request_client
+
+        # @param request_client [CandidApiClient::RequestClient]
+        # @return [CandidApiClient::Tasks::V3::V3Client]
+        def initialize(request_client:)
+          @request_client = request_client
+        end
+
+        # @param task_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::TaskActions]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.get_actions(task_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def get_actions(task_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/tasks/v3/#{task_id}/actions"
+          end
+          CandidApiClient::Tasks::V3::Types::TaskActions.from_json(json_object: response.body)
+        end
+
+        # @param limit [Integer] Defaults to 100
+        # @param page_token [String]
+        # @param status [CandidApiClient::Tasks::Commons::Types::TaskStatus]
+        # @param task_type [CandidApiClient::Tasks::Commons::Types::TaskType]
+        # @param categories [String] Only return tasks with categories that match one in this comma-separated list.
+        # @param updated_since [DateTime] Only return tasks updated on or after this date-time
+        # @param encounter_id [String] Only return tasks associated with this encounter
+        # @param search_term [String] Query tasks by encounter_id, claim_id, task_id, or external_id
+        # @param assigned_to_id [String] Only return tasks assigned to this user
+        # @param date_of_service_min [Date] The minimum date of service for the linked encounter
+        # @param date_of_service_max [Date] The maximum date of service for the linked encounter
+        # @param billing_provider_npi [String] The NPI of the billing provider associated with the task's claim
+        # @param sort [CandidApiClient::Tasks::V3::Types::TaskSortOptions] Defaults to updated_at:desc
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::TaskPage]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.get_multi
+        def get_multi(limit: nil, page_token: nil, status: nil, task_type: nil, categories: nil, updated_since: nil,
+                      encounter_id: nil, search_term: nil, assigned_to_id: nil, date_of_service_min: nil, date_of_service_max: nil, billing_provider_npi: nil, sort: 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 || {}),
+              "limit": limit,
+              "page_token": page_token,
+              "status": status,
+              "task_type": task_type,
+              "categories": categories,
+              "updated_since": updated_since,
+              "encounter_id": encounter_id,
+              "search_term": search_term,
+              "assigned_to_id": assigned_to_id,
+              "date_of_service_min": date_of_service_min,
+              "date_of_service_max": date_of_service_max,
+              "billing_provider_npi": billing_provider_npi,
+              "sort": sort
+            }.compact
+            req.url "#{@request_client.get_url(environment: CandidApi, request_options: request_options)}/api/tasks/v3"
+          end
+          CandidApiClient::Tasks::V3::Types::TaskPage.from_json(json_object: response.body)
+        end
+
+        # @param task_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::Task]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.get(task_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def get(task_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/tasks/v3/#{task_id}"
+          end
+          CandidApiClient::Tasks::V3::Types::Task.from_json(json_object: response.body)
+        end
+
+        # @param request [Hash] Request of type CandidApiClient::Tasks::V3::Types::TaskCreateV3, as a Hash
+        #   * :encounter_id (String)
+        #   * :task_type (CandidApiClient::Tasks::Commons::Types::TaskType)
+        #   * :description (String)
+        #   * :blocks_claim_submission (Boolean)
+        #   * :assignee_user_id (String)
+        #   * :category (CandidApiClient::Tasks::Commons::Types::TaskCategory)
+        #   * :work_queue_id (String)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::Task]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.create(request: { encounter_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", task_type: CUSTOMER_DATA_REQUEST, description: "description", work_queue_id: "work_queue_id" })
+        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/tasks/v3"
+          end
+          CandidApiClient::Tasks::V3::Types::Task.from_json(json_object: response.body)
+        end
+
+        # @param task_id [String]
+        # @param request [Hash] Request of type CandidApiClient::Tasks::V3::Types::TaskUpdateV3, as a Hash
+        #   * :status (CandidApiClient::Tasks::Commons::Types::TaskStatus)
+        #   * :assignee_user_id (String)
+        #   * :blocks_claim_submission (Boolean)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::Task]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.update(task_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", request: {  })
+        def update(task_id:, request:, 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 || {}), **(request_options&.additional_body_parameters || {}) }.compact
+            req.url "#{@request_client.get_url(environment: CandidApi,
+                                               request_options: request_options)}/api/tasks/v3/#{task_id}"
+          end
+          CandidApiClient::Tasks::V3::Types::Task.from_json(json_object: response.body)
+        end
+      end
+
+      class AsyncV3Client
+        # @return [CandidApiClient::AsyncRequestClient]
+        attr_reader :request_client
+
+        # @param request_client [CandidApiClient::AsyncRequestClient]
+        # @return [CandidApiClient::Tasks::V3::AsyncV3Client]
+        def initialize(request_client:)
+          @request_client = request_client
+        end
+
+        # @param task_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::TaskActions]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.get_actions(task_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def get_actions(task_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/tasks/v3/#{task_id}/actions"
+            end
+            CandidApiClient::Tasks::V3::Types::TaskActions.from_json(json_object: response.body)
+          end
+        end
+
+        # @param limit [Integer] Defaults to 100
+        # @param page_token [String]
+        # @param status [CandidApiClient::Tasks::Commons::Types::TaskStatus]
+        # @param task_type [CandidApiClient::Tasks::Commons::Types::TaskType]
+        # @param categories [String] Only return tasks with categories that match one in this comma-separated list.
+        # @param updated_since [DateTime] Only return tasks updated on or after this date-time
+        # @param encounter_id [String] Only return tasks associated with this encounter
+        # @param search_term [String] Query tasks by encounter_id, claim_id, task_id, or external_id
+        # @param assigned_to_id [String] Only return tasks assigned to this user
+        # @param date_of_service_min [Date] The minimum date of service for the linked encounter
+        # @param date_of_service_max [Date] The maximum date of service for the linked encounter
+        # @param billing_provider_npi [String] The NPI of the billing provider associated with the task's claim
+        # @param sort [CandidApiClient::Tasks::V3::Types::TaskSortOptions] Defaults to updated_at:desc
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::TaskPage]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.get_multi
+        def get_multi(limit: nil, page_token: nil, status: nil, task_type: nil, categories: nil, updated_since: nil,
+                      encounter_id: nil, search_term: nil, assigned_to_id: nil, date_of_service_min: nil, date_of_service_max: nil, billing_provider_npi: nil, sort: 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 || {}),
+                "limit": limit,
+                "page_token": page_token,
+                "status": status,
+                "task_type": task_type,
+                "categories": categories,
+                "updated_since": updated_since,
+                "encounter_id": encounter_id,
+                "search_term": search_term,
+                "assigned_to_id": assigned_to_id,
+                "date_of_service_min": date_of_service_min,
+                "date_of_service_max": date_of_service_max,
+                "billing_provider_npi": billing_provider_npi,
+                "sort": sort
+              }.compact
+              req.url "#{@request_client.get_url(environment: CandidApi,
+                                                 request_options: request_options)}/api/tasks/v3"
+            end
+            CandidApiClient::Tasks::V3::Types::TaskPage.from_json(json_object: response.body)
+          end
+        end
+
+        # @param task_id [String]
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::Task]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.get(task_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
+        def get(task_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/tasks/v3/#{task_id}"
+            end
+            CandidApiClient::Tasks::V3::Types::Task.from_json(json_object: response.body)
+          end
+        end
+
+        # @param request [Hash] Request of type CandidApiClient::Tasks::V3::Types::TaskCreateV3, as a Hash
+        #   * :encounter_id (String)
+        #   * :task_type (CandidApiClient::Tasks::Commons::Types::TaskType)
+        #   * :description (String)
+        #   * :blocks_claim_submission (Boolean)
+        #   * :assignee_user_id (String)
+        #   * :category (CandidApiClient::Tasks::Commons::Types::TaskCategory)
+        #   * :work_queue_id (String)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::Task]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.create(request: { encounter_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", task_type: CUSTOMER_DATA_REQUEST, description: "description", work_queue_id: "work_queue_id" })
+        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/tasks/v3"
+            end
+            CandidApiClient::Tasks::V3::Types::Task.from_json(json_object: response.body)
+          end
+        end
+
+        # @param task_id [String]
+        # @param request [Hash] Request of type CandidApiClient::Tasks::V3::Types::TaskUpdateV3, as a Hash
+        #   * :status (CandidApiClient::Tasks::Commons::Types::TaskStatus)
+        #   * :assignee_user_id (String)
+        #   * :blocks_claim_submission (Boolean)
+        # @param request_options [CandidApiClient::RequestOptions]
+        # @return [CandidApiClient::Tasks::V3::Types::Task]
+        # @example
+        #  api = CandidApiClient::Client.new(base_url: "https://api.example.com", environment: CandidApiClient::Environment::PRODUCTION)
+        #  api.tasks.v_3.update(task_id: "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32", request: {  })
+        def update(task_id:, request:, 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 || {}), **(request_options&.additional_body_parameters || {}) }.compact
+              req.url "#{@request_client.get_url(environment: CandidApi,
+                                                 request_options: request_options)}/api/tasks/v3/#{task_id}"
+            end
+            CandidApiClient::Tasks::V3::Types::Task.from_json(json_object: response.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/tasks/v_3/types/task.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require_relative "../../commons/types/task_type"
+require_relative "../../commons/types/task_status"
+require_relative "task_note"
+require "date"
+require_relative "task_assignment"
+require_relative "../../commons/types/task_category"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module Tasks
+    module V3
+      module Types
+        class Task
+          # @return [String]
+          attr_reader :task_id
+          # @return [String]
+          attr_reader :encounter_id
+          # @return [CandidApiClient::Tasks::Commons::Types::TaskType]
+          attr_reader :task_type
+          # @return [String]
+          attr_reader :description
+          # @return [Boolean]
+          attr_reader :blocks_claim_submission
+          # @return [String]
+          attr_reader :external_id
+          # @return [String]
+          attr_reader :patient_name
+          # @return [String]
+          attr_reader :patient_external_id
+          # @return [String]
+          attr_reader :payer_name
+          # @return [String]
+          attr_reader :payer_id
+          # @return [CandidApiClient::Tasks::Commons::Types::TaskStatus]
+          attr_reader :status
+          # @return [Array<CandidApiClient::Tasks::V3::Types::TaskNote>]
+          attr_reader :notes
+          # @return [DateTime]
+          attr_reader :created_at
+          # @return [DateTime] The time of most recent update to the task only
+          attr_reader :updated_at
+          # @return [DateTime] The time of most recent update to the task or any of its notes
+          attr_reader :agg_updated_at
+          # @return [Date]
+          attr_reader :date_of_service
+          # @return [Array<CandidApiClient::Tasks::V3::Types::TaskAssignment>]
+          attr_reader :assignments
+          # @return [CandidApiClient::Tasks::Commons::Types::TaskCategory]
+          attr_reader :category
+          # @return [String]
+          attr_reader :configurable_rule_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 task_id [String]
+          # @param encounter_id [String]
+          # @param task_type [CandidApiClient::Tasks::Commons::Types::TaskType]
+          # @param description [String]
+          # @param blocks_claim_submission [Boolean]
+          # @param external_id [String]
+          # @param patient_name [String]
+          # @param patient_external_id [String]
+          # @param payer_name [String]
+          # @param payer_id [String]
+          # @param status [CandidApiClient::Tasks::Commons::Types::TaskStatus]
+          # @param notes [Array<CandidApiClient::Tasks::V3::Types::TaskNote>]
+          # @param created_at [DateTime]
+          # @param updated_at [DateTime] The time of most recent update to the task only
+          # @param agg_updated_at [DateTime] The time of most recent update to the task or any of its notes
+          # @param date_of_service [Date]
+          # @param assignments [Array<CandidApiClient::Tasks::V3::Types::TaskAssignment>]
+          # @param category [CandidApiClient::Tasks::Commons::Types::TaskCategory]
+          # @param configurable_rule_id [String]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::Tasks::V3::Types::Task]
+          def initialize(task_id:, encounter_id:, task_type:, description:, blocks_claim_submission:, external_id:,
+                         patient_name:, patient_external_id:, status:, notes:, created_at:, updated_at:, agg_updated_at:, date_of_service:, assignments:, payer_name: OMIT, payer_id: OMIT, category: OMIT, configurable_rule_id: OMIT, additional_properties: nil)
+            @task_id = task_id
+            @encounter_id = encounter_id
+            @task_type = task_type
+            @description = description
+            @blocks_claim_submission = blocks_claim_submission
+            @external_id = external_id
+            @patient_name = patient_name
+            @patient_external_id = patient_external_id
+            @payer_name = payer_name if payer_name != OMIT
+            @payer_id = payer_id if payer_id != OMIT
+            @status = status
+            @notes = notes
+            @created_at = created_at
+            @updated_at = updated_at
+            @agg_updated_at = agg_updated_at
+            @date_of_service = date_of_service
+            @assignments = assignments
+            @category = category if category != OMIT
+            @configurable_rule_id = configurable_rule_id if configurable_rule_id != OMIT
+            @additional_properties = additional_properties
+            @_field_set = {
+              "task_id": task_id,
+              "encounter_id": encounter_id,
+              "task_type": task_type,
+              "description": description,
+              "blocks_claim_submission": blocks_claim_submission,
+              "external_id": external_id,
+              "patient_name": patient_name,
+              "patient_external_id": patient_external_id,
+              "payer_name": payer_name,
+              "payer_id": payer_id,
+              "status": status,
+              "notes": notes,
+              "created_at": created_at,
+              "updated_at": updated_at,
+              "agg_updated_at": agg_updated_at,
+              "date_of_service": date_of_service,
+              "assignments": assignments,
+              "category": category,
+              "configurable_rule_id": configurable_rule_id
+            }.reject do |_k, v|
+              v == OMIT
+            end
+          end
+
+          # Deserialize a JSON object to an instance of Task
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::Tasks::V3::Types::Task]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            parsed_json = JSON.parse(json_object)
+            task_id = struct["task_id"]
+            encounter_id = struct["encounter_id"]
+            task_type = struct["task_type"]
+            description = struct["description"]
+            blocks_claim_submission = struct["blocks_claim_submission"]
+            external_id = struct["external_id"]
+            patient_name = struct["patient_name"]
+            patient_external_id = struct["patient_external_id"]
+            payer_name = struct["payer_name"]
+            payer_id = struct["payer_id"]
+            status = struct["status"]
+            notes = parsed_json["notes"]&.map do |item|
+              item = item.to_json
+              CandidApiClient::Tasks::V3::Types::TaskNote.from_json(json_object: item)
+            end
+            created_at = (DateTime.parse(parsed_json["created_at"]) unless parsed_json["created_at"].nil?)
+            updated_at = (DateTime.parse(parsed_json["updated_at"]) unless parsed_json["updated_at"].nil?)
+            agg_updated_at = (DateTime.parse(parsed_json["agg_updated_at"]) unless parsed_json["agg_updated_at"].nil?)
+            date_of_service = (Date.parse(parsed_json["date_of_service"]) unless parsed_json["date_of_service"].nil?)
+            assignments = parsed_json["assignments"]&.map do |item|
+              item = item.to_json
+              CandidApiClient::Tasks::V3::Types::TaskAssignment.from_json(json_object: item)
+            end
+            category = struct["category"]
+            configurable_rule_id = struct["configurable_rule_id"]
+            new(
+              task_id: task_id,
+              encounter_id: encounter_id,
+              task_type: task_type,
+              description: description,
+              blocks_claim_submission: blocks_claim_submission,
+              external_id: external_id,
+              patient_name: patient_name,
+              patient_external_id: patient_external_id,
+              payer_name: payer_name,
+              payer_id: payer_id,
+              status: status,
+              notes: notes,
+              created_at: created_at,
+              updated_at: updated_at,
+              agg_updated_at: agg_updated_at,
+              date_of_service: date_of_service,
+              assignments: assignments,
+              category: category,
+              configurable_rule_id: configurable_rule_id,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of Task 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.task_id.is_a?(String) != false || raise("Passed value for field obj.task_id is not the expected type, validation failed.")
+            obj.encounter_id.is_a?(String) != false || raise("Passed value for field obj.encounter_id is not the expected type, validation failed.")
+            obj.task_type.is_a?(CandidApiClient::Tasks::Commons::Types::TaskType) != false || raise("Passed value for field obj.task_type is not the expected type, validation failed.")
+            obj.description.is_a?(String) != false || raise("Passed value for field obj.description is not the expected type, validation failed.")
+            obj.blocks_claim_submission.is_a?(Boolean) != false || raise("Passed value for field obj.blocks_claim_submission is not the expected type, validation failed.")
+            obj.external_id.is_a?(String) != false || raise("Passed value for field obj.external_id is not the expected type, validation failed.")
+            obj.patient_name.is_a?(String) != false || raise("Passed value for field obj.patient_name is not the expected type, validation failed.")
+            obj.patient_external_id.is_a?(String) != false || raise("Passed value for field obj.patient_external_id is not the expected type, validation failed.")
+            obj.payer_name&.is_a?(String) != false || raise("Passed value for field obj.payer_name is not the expected type, validation failed.")
+            obj.payer_id&.is_a?(String) != false || raise("Passed value for field obj.payer_id is not the expected type, validation failed.")
+            obj.status.is_a?(CandidApiClient::Tasks::Commons::Types::TaskStatus) != false || raise("Passed value for field obj.status is not the expected type, validation failed.")
+            obj.notes.is_a?(Array) != false || raise("Passed value for field obj.notes is not the expected type, validation failed.")
+            obj.created_at.is_a?(DateTime) != false || raise("Passed value for field obj.created_at is not the expected type, validation failed.")
+            obj.updated_at.is_a?(DateTime) != false || raise("Passed value for field obj.updated_at is not the expected type, validation failed.")
+            obj.agg_updated_at.is_a?(DateTime) != false || raise("Passed value for field obj.agg_updated_at 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.assignments.is_a?(Array) != false || raise("Passed value for field obj.assignments is not the expected type, validation failed.")
+            obj.category&.is_a?(CandidApiClient::Tasks::Commons::Types::TaskCategory) != false || raise("Passed value for field obj.category is not the expected type, validation failed.")
+            obj.configurable_rule_id&.is_a?(String) != false || raise("Passed value for field obj.configurable_rule_id is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/candidhealth/tasks/v_3/types/task_action.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "task_action_execution_method"
+require_relative "task_action_type"
+require "ostruct"
+require "json"
+
+module CandidApiClient
+  module Tasks
+    module V3
+      module Types
+        class TaskAction
+          # @return [String]
+          attr_reader :display_name
+          # @return [CandidApiClient::Tasks::V3::Types::TaskActionExecutionMethod]
+          attr_reader :execution_method
+          # @return [CandidApiClient::Tasks::V3::Types::TaskActionType]
+          attr_reader :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 display_name [String]
+          # @param execution_method [CandidApiClient::Tasks::V3::Types::TaskActionExecutionMethod]
+          # @param type [CandidApiClient::Tasks::V3::Types::TaskActionType]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::Tasks::V3::Types::TaskAction]
+          def initialize(display_name:, execution_method:, type:, additional_properties: nil)
+            @display_name = display_name
+            @execution_method = execution_method
+            @type = type
+            @additional_properties = additional_properties
+            @_field_set = { "display_name": display_name, "execution_method": execution_method, "type": type }
+          end
+
+          # Deserialize a JSON object to an instance of TaskAction
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::Tasks::V3::Types::TaskAction]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            parsed_json = JSON.parse(json_object)
+            display_name = struct["display_name"]
+            if parsed_json["execution_method"].nil?
+              execution_method = nil
+            else
+              execution_method = parsed_json["execution_method"].to_json
+              execution_method = CandidApiClient::Tasks::V3::Types::TaskActionExecutionMethod.from_json(json_object: execution_method)
+            end
+            type = struct["type"]
+            new(
+              display_name: display_name,
+              execution_method: execution_method,
+              type: type,
+              additional_properties: struct
+            )
+          end
+
+          # Serialize an instance of TaskAction 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.display_name.is_a?(String) != false || raise("Passed value for field obj.display_name is not the expected type, validation failed.")
+            CandidApiClient::Tasks::V3::Types::TaskActionExecutionMethod.validate_raw(obj: obj.execution_method)
+            obj.type.is_a?(CandidApiClient::Tasks::V3::Types::TaskActionType) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+          end
+        end
+      end
+    end
+  end
+end