candidhealth 0.17.1

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

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require_relative "../../../requests"
+require_relative "../../commons/types/task_id"
+require_relative "types/task_actions"
+require_relative "../../commons/types/page_token"
+require_relative "../commons/types/task_status"
+require_relative "../commons/types/task_type"
+require "date"
+require_relative "../../commons/types/encounter_id"
+require_relative "../../commons/types/user_id"
+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
+        attr_reader :request_client
+
+        # @param request_client [RequestClient]
+        # @return [Tasks::V3::V3Client]
+        def initialize(request_client:)
+          # @type [RequestClient]
+          @request_client = request_client
+        end
+
+        # @param task_id [Commons::TASK_ID]
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::TaskActions]
+        def get_actions(task_id:, request_options: nil)
+          response = @request_client.conn.get("/api/tasks/v3/#{task_id}/actions") 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_options&.additional_headers || {}) }.compact
+          end
+          Tasks::V3::TaskActions.from_json(json_object: response.body)
+        end
+
+        # @param limit [Integer] Defaults to 100
+        # @param page_token [Commons::PAGE_TOKEN]
+        # @param status [Tasks::Commons::TaskStatus]
+        # @param task_type [Tasks::Commons::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 [Commons::ENCOUNTER_ID] 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 [Commons::USER_ID] 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 [Tasks::V3::TaskSortOptions] Defaults to updated_at:desc
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::TaskPage]
+        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("/api/tasks/v3") 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_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
+          end
+          Tasks::V3::TaskPage.from_json(json_object: response.body)
+        end
+
+        # @param task_id [Commons::TASK_ID]
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::Task]
+        def get(task_id:, request_options: nil)
+          response = @request_client.conn.get("/api/tasks/v3/#{task_id}") 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_options&.additional_headers || {}) }.compact
+          end
+          Tasks::V3::Task.from_json(json_object: response.body)
+        end
+
+        # @param request [Hash] Request of type Tasks::V3::TaskCreateV3, as a Hash
+        #   * :encounter_id (Commons::ENCOUNTER_ID)
+        #   * :task_type (Tasks::Commons::TaskType)
+        #   * :description (String)
+        #   * :blocks_claim_submission (Boolean)
+        #   * :assignee_user_id (Commons::USER_ID)
+        #   * :category (Tasks::Commons::TaskCategory)
+        #   * :work_queue_id (Commons::WORK_QUEUE_ID)
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::Task]
+        def create(request:, request_options: nil)
+          response = @request_client.conn.post("/api/tasks/v3") 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_options&.additional_headers || {}) }.compact
+            req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+          end
+          Tasks::V3::Task.from_json(json_object: response.body)
+        end
+
+        # @param task_id [Commons::TASK_ID]
+        # @param request [Hash] Request of type Tasks::V3::TaskUpdateV3, as a Hash
+        #   * :status (Tasks::Commons::TaskStatus)
+        #   * :assignee_user_id (Commons::USER_ID)
+        #   * :blocks_claim_submission (Boolean)
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::Task]
+        def update(task_id:, request:, request_options: nil)
+          response = @request_client.conn.patch("/api/tasks/v3/#{task_id}") 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_options&.additional_headers || {}) }.compact
+            req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+          end
+          Tasks::V3::Task.from_json(json_object: response.body)
+        end
+      end
+
+      class AsyncV3Client
+        attr_reader :request_client
+
+        # @param request_client [AsyncRequestClient]
+        # @return [Tasks::V3::AsyncV3Client]
+        def initialize(request_client:)
+          # @type [AsyncRequestClient]
+          @request_client = request_client
+        end
+
+        # @param task_id [Commons::TASK_ID]
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::TaskActions]
+        def get_actions(task_id:, request_options: nil)
+          Async do
+            response = @request_client.conn.get("/api/tasks/v3/#{task_id}/actions") 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_options&.additional_headers || {}) }.compact
+            end
+            Tasks::V3::TaskActions.from_json(json_object: response.body)
+          end
+        end
+
+        # @param limit [Integer] Defaults to 100
+        # @param page_token [Commons::PAGE_TOKEN]
+        # @param status [Tasks::Commons::TaskStatus]
+        # @param task_type [Tasks::Commons::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 [Commons::ENCOUNTER_ID] 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 [Commons::USER_ID] 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 [Tasks::V3::TaskSortOptions] Defaults to updated_at:desc
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::TaskPage]
+        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("/api/tasks/v3") 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_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
+            end
+            Tasks::V3::TaskPage.from_json(json_object: response.body)
+          end
+        end
+
+        # @param task_id [Commons::TASK_ID]
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::Task]
+        def get(task_id:, request_options: nil)
+          Async do
+            response = @request_client.conn.get("/api/tasks/v3/#{task_id}") 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_options&.additional_headers || {}) }.compact
+            end
+            Tasks::V3::Task.from_json(json_object: response.body)
+          end
+        end
+
+        # @param request [Hash] Request of type Tasks::V3::TaskCreateV3, as a Hash
+        #   * :encounter_id (Commons::ENCOUNTER_ID)
+        #   * :task_type (Tasks::Commons::TaskType)
+        #   * :description (String)
+        #   * :blocks_claim_submission (Boolean)
+        #   * :assignee_user_id (Commons::USER_ID)
+        #   * :category (Tasks::Commons::TaskCategory)
+        #   * :work_queue_id (Commons::WORK_QUEUE_ID)
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::Task]
+        def create(request:, request_options: nil)
+          Async do
+            response = @request_client.conn.post("/api/tasks/v3") 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_options&.additional_headers || {}) }.compact
+              req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+            end
+            Tasks::V3::Task.from_json(json_object: response.body)
+          end
+        end
+
+        # @param task_id [Commons::TASK_ID]
+        # @param request [Hash] Request of type Tasks::V3::TaskUpdateV3, as a Hash
+        #   * :status (Tasks::Commons::TaskStatus)
+        #   * :assignee_user_id (Commons::USER_ID)
+        #   * :blocks_claim_submission (Boolean)
+        # @param request_options [RequestOptions]
+        # @return [Tasks::V3::Task]
+        def update(task_id:, request:, request_options: nil)
+          Async do
+            response = @request_client.conn.patch("/api/tasks/v3/#{task_id}") 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_options&.additional_headers || {}) }.compact
+              req.body = { **(request || {}), **(request_options&.additional_body_parameters || {}) }.compact
+            end
+            Tasks::V3::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,170 @@
+# frozen_string_literal: true
+
+require_relative "../../../commons/types/task_id"
+require_relative "../../../commons/types/encounter_id"
+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 "json"
+
+module CandidApiClient
+  module Tasks
+    module V3
+      class Task
+        attr_reader :task_id, :encounter_id, :task_type, :description, :blocks_claim_submission, :external_id,
+                    :patient_name, :patient_external_id, :payer_name, :payer_id, :status, :notes, :created_at, :updated_at, :agg_updated_at, :date_of_service, :assignments, :category, :additional_properties
+
+        # @param task_id [Commons::TASK_ID]
+        # @param encounter_id [Commons::ENCOUNTER_ID]
+        # @param task_type [Tasks::Commons::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 [Tasks::Commons::TaskStatus]
+        # @param notes [Array<Tasks::V3::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<Tasks::V3::TaskAssignment>]
+        # @param category [Tasks::Commons::TaskCategory]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Tasks::V3::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: nil, payer_id: nil, category: nil, additional_properties: nil)
+          # @type [Commons::TASK_ID]
+          @task_id = task_id
+          # @type [Commons::ENCOUNTER_ID]
+          @encounter_id = encounter_id
+          # @type [Tasks::Commons::TaskType]
+          @task_type = task_type
+          # @type [String]
+          @description = description
+          # @type [Boolean]
+          @blocks_claim_submission = blocks_claim_submission
+          # @type [String]
+          @external_id = external_id
+          # @type [String]
+          @patient_name = patient_name
+          # @type [String]
+          @patient_external_id = patient_external_id
+          # @type [String]
+          @payer_name = payer_name
+          # @type [String]
+          @payer_id = payer_id
+          # @type [Tasks::Commons::TaskStatus]
+          @status = status
+          # @type [Array<Tasks::V3::TaskNote>]
+          @notes = notes
+          # @type [DateTime]
+          @created_at = created_at
+          # @type [DateTime] The time of most recent update to the task only
+          @updated_at = updated_at
+          # @type [DateTime] The time of most recent update to the task or any of its notes
+          @agg_updated_at = agg_updated_at
+          # @type [Date]
+          @date_of_service = date_of_service
+          # @type [Array<Tasks::V3::TaskAssignment>]
+          @assignments = assignments
+          # @type [Tasks::Commons::TaskCategory]
+          @category = category
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of Task
+        #
+        # @param json_object [JSON]
+        # @return [Tasks::V3::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 |v|
+            v = v.to_json
+            Tasks::V3::TaskNote.from_json(json_object: v)
+          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 |v|
+            v = v.to_json
+            Tasks::V3::TaskAssignment.from_json(json_object: v)
+          end
+          category = struct.category
+          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, additional_properties: struct)
+        end
+
+        # Serialize an instance of Task to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          {
+            "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
+          }.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?(Tasks::Commons::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?(Tasks::Commons::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?(Tasks::Commons::TaskCategory) != false || raise("Passed value for field obj.category is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CandidApiClient
+  module Tasks
+    module V3
+      class TaskActionExecutionMethod
+        attr_reader :member, :discriminant
+
+        private_class_method :new
+        alias kind_of? is_a?
+        # @param member [Object]
+        # @param discriminant [String]
+        # @return [Tasks::V3::TaskActionExecutionMethod]
+        def initialize(member:, discriminant:)
+          # @type [Object]
+          @member = member
+          # @type [String]
+          @discriminant = discriminant
+        end
+
+        # Deserialize a JSON object to an instance of TaskActionExecutionMethod
+        #
+        # @param json_object [JSON]
+        # @return [Tasks::V3::TaskActionExecutionMethod]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          member = case struct.type
+                   when "close_task"
+                     nil
+                   else
+                     json_object
+                   end
+          new(member: member, discriminant: struct.type)
+        end
+
+        # For Union Types, to_json functionality is delegated to the wrapped member.
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          case @discriminant
+          when "close_task"
+            { type: @discriminant }.to_json
+          else
+            { "type": @discriminant, value: @member }.to_json
+          end
+          @member.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:)
+          case obj.type
+          when "close_task"
+            # noop
+          else
+            raise("Passed value matched no type within the union, validation failed.")
+          end
+        end
+
+        # For Union Types, is_a? functionality is delegated to the wrapped member.
+        #
+        # @param obj [Object]
+        # @return [Boolean]
+        def is_a?(obj)
+          @member.is_a?(obj)
+        end
+
+        # @return [Tasks::V3::TaskActionExecutionMethod]
+        def self.close_task
+          new(member: nil, discriminant: "close_task")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CandidApiClient
+  module Tasks
+    module V3
+      class TaskActionType
+        CLOSE_TASK = "close_task"
+        CLOSE_TASK_AND_REPROCESS = "close_task_and_reprocess"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "task_action"
+require "json"
+
+module CandidApiClient
+  module Tasks
+    module V3
+      class TaskActions
+        attr_reader :actions, :additional_properties
+
+        # @param actions [Array<Tasks::V3::TaskAction>]
+        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+        # @return [Tasks::V3::TaskActions]
+        def initialize(actions:, additional_properties: nil)
+          # @type [Array<Tasks::V3::TaskAction>]
+          @actions = actions
+          # @type [OpenStruct] Additional properties unmapped to the current class definition
+          @additional_properties = additional_properties
+        end
+
+        # Deserialize a JSON object to an instance of TaskActions
+        #
+        # @param json_object [JSON]
+        # @return [Tasks::V3::TaskActions]
+        def self.from_json(json_object:)
+          struct = JSON.parse(json_object, object_class: OpenStruct)
+          parsed_json = JSON.parse(json_object)
+          actions = parsed_json["actions"]&.map do |v|
+            v = v.to_json
+            Tasks::V3::TaskAction.from_json(json_object: v)
+          end
+          new(actions: actions, additional_properties: struct)
+        end
+
+        # Serialize an instance of TaskActions to a JSON object
+        #
+        # @return [JSON]
+        def to_json(*_args)
+          { "actions": @actions }.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.actions.is_a?(Array) != false || raise("Passed value for field obj.actions is not the expected type, validation failed.")
+        end
+      end
+    end
+  end
+end