merge_ruby_client 0.1.2 → 0.1.4

data/lib/merge_ruby_client/ats/types/paginated_eeoc_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Eeoc.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Eeoc.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_issue_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Issue.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Issue.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_job_interview_stage_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::JobInterviewStage.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::JobInterviewStage.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_job_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Job.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Job.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_job_posting_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::JobPosting.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::JobPosting.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_offer_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Offer.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Offer.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_office_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Office.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Office.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_reject_reason_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RejectReason.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RejectReason.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_remote_user_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteUser.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteUser.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_scheduled_interview_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::ScheduledInterview.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::ScheduledInterview.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_scorecard_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Scorecard.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Scorecard.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_screening_question_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::ScreeningQuestion.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::ScreeningQuestion.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_sync_status_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::SyncStatus.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::SyncStatus.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/paginated_tag_list.rb

@@ -43,11 +43,11 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        next_ = struct["next"]
-        previous = struct["previous"]
-        results = parsed_json["results"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::Tag.from_json(json_object: v)
+        next_ = parsed_json["next"]
+        previous = parsed_json["previous"]
+        results = parsed_json["results"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::Tag.from_json(json_object: item)
         end
         new(
           next_: next_,

data/lib/merge_ruby_client/ats/types/patched_candidate_request.rb

@@ -129,34 +129,34 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        first_name = struct["first_name"]
-        last_name = struct["last_name"]
-        company = struct["company"]
-        title = struct["title"]
+        first_name = parsed_json["first_name"]
+        last_name = parsed_json["last_name"]
+        company = parsed_json["company"]
+        title = parsed_json["title"]
         last_interaction_at = unless parsed_json["last_interaction_at"].nil?
                                 DateTime.parse(parsed_json["last_interaction_at"])
                               end
-        is_private = struct["is_private"]
-        can_email = struct["can_email"]
-        locations = struct["locations"]
-        phone_numbers = parsed_json["phone_numbers"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::PhoneNumberRequest.from_json(json_object: v)
+        is_private = parsed_json["is_private"]
+        can_email = parsed_json["can_email"]
+        locations = parsed_json["locations"]
+        phone_numbers = parsed_json["phone_numbers"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::PhoneNumberRequest.from_json(json_object: item)
         end
-        email_addresses = parsed_json["email_addresses"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::EmailAddressRequest.from_json(json_object: v)
+        email_addresses = parsed_json["email_addresses"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::EmailAddressRequest.from_json(json_object: item)
         end
-        urls = parsed_json["urls"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::UrlRequest.from_json(json_object: v)
+        urls = parsed_json["urls"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::UrlRequest.from_json(json_object: item)
         end
-        tags = struct["tags"]
-        applications = struct["applications"]
-        attachments = struct["attachments"]
-        remote_template_id = struct["remote_template_id"]
-        integration_params = struct["integration_params"]
-        linked_account_params = struct["linked_account_params"]
+        tags = parsed_json["tags"]
+        applications = parsed_json["applications"]
+        attachments = parsed_json["attachments"]
+        remote_template_id = parsed_json["remote_template_id"]
+        integration_params = parsed_json["integration_params"]
+        linked_account_params = parsed_json["linked_account_params"]
         new(
           first_name: first_name,
           last_name: last_name,

data/lib/merge_ruby_client/ats/types/phone_number.rb

@@ -26,6 +26,9 @@ module Merge
       #  - `SKYPE` - SKYPE
       #  - `OTHER` - OTHER
       attr_reader :phone_number_type
+      # @return [Boolean] Indicates whether or not this object has been deleted in the third party
+      #  platform.
+      attr_reader :remote_was_deleted
       # @return [OpenStruct] Additional properties unmapped to the current class definition
       attr_reader :additional_properties
       # @return [Object]
@@ -43,20 +46,24 @@ module Merge
       #  - `MOBILE` - MOBILE
       #  - `SKYPE` - SKYPE
       #  - `OTHER` - OTHER
+      # @param remote_was_deleted [Boolean] Indicates whether or not this object has been deleted in the third party
+      #  platform.
       # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
       # @return [Merge::Ats::PhoneNumber]
       def initialize(created_at: OMIT, modified_at: OMIT, value: OMIT, phone_number_type: OMIT,
-                     additional_properties: nil)
+                     remote_was_deleted: OMIT, additional_properties: nil)
         @created_at = created_at if created_at != OMIT
         @modified_at = modified_at if modified_at != OMIT
         @value = value if value != OMIT
         @phone_number_type = phone_number_type if phone_number_type != OMIT
+        @remote_was_deleted = remote_was_deleted if remote_was_deleted != OMIT
         @additional_properties = additional_properties
         @_field_set = {
           "created_at": created_at,
           "modified_at": modified_at,
           "value": value,
-          "phone_number_type": phone_number_type
+          "phone_number_type": phone_number_type,
+          "remote_was_deleted": remote_was_deleted
         }.reject do |_k, v|
           v == OMIT
         end
@@ -71,13 +78,15 @@ module Merge
         parsed_json = JSON.parse(json_object)
         created_at = (DateTime.parse(parsed_json["created_at"]) unless parsed_json["created_at"].nil?)
         modified_at = (DateTime.parse(parsed_json["modified_at"]) unless parsed_json["modified_at"].nil?)
-        value = struct["value"]
-        phone_number_type = struct["phone_number_type"]
+        value = parsed_json["value"]
+        phone_number_type = parsed_json["phone_number_type"]
+        remote_was_deleted = parsed_json["remote_was_deleted"]
         new(
           created_at: created_at,
           modified_at: modified_at,
           value: value,
           phone_number_type: phone_number_type,
+          remote_was_deleted: remote_was_deleted,
           additional_properties: struct
         )
       end
@@ -100,6 +109,7 @@ module Merge
         obj.modified_at&.is_a?(DateTime) != false || raise("Passed value for field obj.modified_at is not the expected type, validation failed.")
         obj.value&.is_a?(String) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
         obj.phone_number_type&.is_a?(Merge::Ats::PhoneNumberTypeEnum) != false || raise("Passed value for field obj.phone_number_type is not the expected type, validation failed.")
+        obj.remote_was_deleted&.is_a?(Boolean) != false || raise("Passed value for field obj.remote_was_deleted is not the expected type, validation failed.")
       end
     end
   end

data/lib/merge_ruby_client/ats/types/phone_number_request.rb

@@ -67,10 +67,11 @@ module Merge
       # @return [Merge::Ats::PhoneNumberRequest]
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
-        value = struct["value"]
-        phone_number_type = struct["phone_number_type"]
-        integration_params = struct["integration_params"]
-        linked_account_params = struct["linked_account_params"]
+        parsed_json = JSON.parse(json_object)
+        value = parsed_json["value"]
+        phone_number_type = parsed_json["phone_number_type"]
+        integration_params = parsed_json["integration_params"]
+        linked_account_params = parsed_json["linked_account_params"]
         new(
           value: value,
           phone_number_type: phone_number_type,

data/lib/merge_ruby_client/ats/types/reject_reason.rb

@@ -83,16 +83,16 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        id = struct["id"]
-        remote_id = struct["remote_id"]
+        id = parsed_json["id"]
+        remote_id = parsed_json["remote_id"]
         created_at = (DateTime.parse(parsed_json["created_at"]) unless parsed_json["created_at"].nil?)
         modified_at = (DateTime.parse(parsed_json["modified_at"]) unless parsed_json["modified_at"].nil?)
-        name = struct["name"]
-        remote_was_deleted = struct["remote_was_deleted"]
-        field_mappings = struct["field_mappings"]
-        remote_data = parsed_json["remote_data"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteData.from_json(json_object: v)
+        name = parsed_json["name"]
+        remote_was_deleted = parsed_json["remote_was_deleted"]
+        field_mappings = parsed_json["field_mappings"]
+        remote_data = parsed_json["remote_data"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteData.from_json(json_object: item)
         end
         new(
           id: id,

data/lib/merge_ruby_client/ats/types/remote_data.rb

@@ -37,8 +37,9 @@ module Merge
       # @return [Merge::Ats::RemoteData]
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
-        path = struct["path"]
-        data = struct["data"]
+        parsed_json = JSON.parse(json_object)
+        path = parsed_json["path"]
+        data = parsed_json["data"]
         new(
           path: path,
           data: data,

data/lib/merge_ruby_client/ats/types/remote_endpoint_info.rb

@@ -39,9 +39,10 @@ module Merge
       # @return [Merge::Ats::RemoteEndpointInfo]
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
-        method = struct["method"]
-        url_path = struct["url_path"]
-        field_traversal_path = struct["field_traversal_path"]
+        parsed_json = JSON.parse(json_object)
+        method = parsed_json["method"]
+        url_path = parsed_json["url_path"]
+        field_traversal_path = parsed_json["field_traversal_path"]
         new(
           method: method,
           url_path: url_path,

data/lib/merge_ruby_client/ats/types/remote_field_api.rb

@@ -37,12 +37,12 @@ module Merge
       # @param coverage [Merge::Ats::RemoteFieldApiCoverage]
       # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
       # @return [Merge::Ats::RemoteFieldApi]
-      def initialize(schema:, remote_key_name:, remote_endpoint_info:, example_values:, advanced_metadata: OMIT,
+      def initialize(schema:, remote_key_name:, remote_endpoint_info:, example_values: OMIT, advanced_metadata: OMIT,
                      coverage: OMIT, additional_properties: nil)
         @schema = schema
         @remote_key_name = remote_key_name
         @remote_endpoint_info = remote_endpoint_info
-        @example_values = example_values
+        @example_values = example_values if example_values != OMIT
         @advanced_metadata = advanced_metadata if advanced_metadata != OMIT
         @coverage = coverage if coverage != OMIT
         @additional_properties = additional_properties
@@ -65,15 +65,15 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        schema = struct["schema"]
-        remote_key_name = struct["remote_key_name"]
+        schema = parsed_json["schema"]
+        remote_key_name = parsed_json["remote_key_name"]
         if parsed_json["remote_endpoint_info"].nil?
           remote_endpoint_info = nil
         else
           remote_endpoint_info = parsed_json["remote_endpoint_info"].to_json
           remote_endpoint_info = Merge::Ats::RemoteEndpointInfo.from_json(json_object: remote_endpoint_info)
         end
-        example_values = struct["example_values"]
+        example_values = parsed_json["example_values"]
         if parsed_json["advanced_metadata"].nil?
           advanced_metadata = nil
         else
@@ -114,7 +114,7 @@ module Merge
         obj.schema.is_a?(Hash) != false || raise("Passed value for field obj.schema is not the expected type, validation failed.")
         obj.remote_key_name.is_a?(String) != false || raise("Passed value for field obj.remote_key_name is not the expected type, validation failed.")
         Merge::Ats::RemoteEndpointInfo.validate_raw(obj: obj.remote_endpoint_info)
-        obj.example_values.is_a?(Array) != false || raise("Passed value for field obj.example_values is not the expected type, validation failed.")
+        obj.example_values&.is_a?(Array) != false || raise("Passed value for field obj.example_values is not the expected type, validation failed.")
         obj.advanced_metadata.nil? || Merge::Ats::AdvancedMetadata.validate_raw(obj: obj.advanced_metadata)
         obj.coverage.nil? || Merge::Ats::RemoteFieldApiCoverage.validate_raw(obj: obj.coverage)
       end

data/lib/merge_ruby_client/ats/types/remote_field_api_coverage.rb

@@ -13,7 +13,7 @@ module Merge
         struct = JSON.parse(json_object, object_class: OpenStruct)
         begin
           struct.is_a?(Integer) != false || raise("Passed value for field struct is not the expected type, validation failed.")
-          return json_object unless json_object.nil?
+          return struct unless struct.nil?
 
           return nil
         rescue StandardError
@@ -21,7 +21,7 @@ module Merge
         end
         begin
           struct.is_a?(Float) != false || raise("Passed value for field struct is not the expected type, validation failed.")
-          return json_object unless json_object.nil?
+          return struct unless struct.nil?
 
           return nil
         rescue StandardError

data/lib/merge_ruby_client/ats/types/remote_field_api_response.rb

@@ -113,69 +113,69 @@ module Merge
       def self.from_json(json_object:)
         struct = JSON.parse(json_object, object_class: OpenStruct)
         parsed_json = JSON.parse(json_object)
-        activity = parsed_json["Activity"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        activity = parsed_json["Activity"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        application = parsed_json["Application"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        application = parsed_json["Application"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        attachment = parsed_json["Attachment"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        attachment = parsed_json["Attachment"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        candidate = parsed_json["Candidate"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        candidate = parsed_json["Candidate"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        department = parsed_json["Department"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        department = parsed_json["Department"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        eeoc = parsed_json["EEOC"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        eeoc = parsed_json["EEOC"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        scheduled_interview = parsed_json["ScheduledInterview"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        scheduled_interview = parsed_json["ScheduledInterview"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        job = parsed_json["Job"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        job = parsed_json["Job"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        job_posting = parsed_json["JobPosting"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        job_posting = parsed_json["JobPosting"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        job_interview_stage = parsed_json["JobInterviewStage"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        job_interview_stage = parsed_json["JobInterviewStage"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        offer = parsed_json["Offer"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        offer = parsed_json["Offer"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        office = parsed_json["Office"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        office = parsed_json["Office"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        reject_reason = parsed_json["RejectReason"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        reject_reason = parsed_json["RejectReason"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        scorecard = parsed_json["Scorecard"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        scorecard = parsed_json["Scorecard"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        tag = parsed_json["Tag"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        tag = parsed_json["Tag"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
-        remote_user = parsed_json["RemoteUser"]&.map do |v|
-          v = v.to_json
-          Merge::Ats::RemoteFieldApi.from_json(json_object: v)
+        remote_user = parsed_json["RemoteUser"]&.map do |item|
+          item = item.to_json
+          Merge::Ats::RemoteFieldApi.from_json(json_object: item)
         end
         new(
           activity: activity,