stackone_client 0.36.0 → 0.37.0

data/lib/stack_one/ats.rb

@@ -2475,7 +2475,7 @@ module StackOne
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
       query_params = Utils.get_query_params(Models::Operations::AtsDownloadApplicationDocumentRequest, request, nil)
-      headers['Accept'] = 'application/octet-stream'
+      headers['Accept'] = 'application/json;q=1, text/csv;q=0.97, text/plain;q=0.95, application/gzip;q=0.92, application/msword;q=0.89, application/octet-stream;q=0.87, application/pdf;q=0.84, application/rtf;q=0.82, application/vnd.ms-excel;q=0.79, application/vnd.ms-outlook;q=0.76, application/vnd.ms-powerpoint;q=0.74, application/vnd.oasis.opendocument.presentation;q=0.71, application/vnd.oasis.opendocument.spreadsheet;q=0.68, application/vnd.oasis.opendocument.text;q=0.66, application/vnd.openxmlformats-officedocument.presentationml.presentation;q=0.63, application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;q=0.61, application/vnd.openxmlformats-officedocument.wordprocessingml.document;q=0.58, application/x-7z-compressed;q=0.55, application/x-rar-compressed;q=0.53, application/xml;q=0.50, application/zip;q=0.47, audio/mp4;q=0.45, audio/mpeg;q=0.42, audio/wav;q=0.39, image/bmp;q=0.37, image/gif;q=0.34, image/heic;q=0.32, image/jpeg;q=0.29, image/png;q=0.26, image/tiff;q=0.24, image/webp;q=0.21, message/rfc822;q=0.18, text/html;q=0.16, text/rtf;q=0.13, video/avi;q=0.11, video/mp4;q=0.08, video/quicktime;q=0.05, video/webm;q=0'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
       retries ||= Utils::RetryConfig.new(
@@ -2554,7 +2554,7 @@ module StackOne
       
       content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
       if Utils.match_status_code(http_response.status, ['200'])
-        if Utils.match_content_type(content_type, 'application/octet-stream')
+        if Utils.match_content_type(content_type, 'application/gzip')
           http_response = @sdk_configuration.hooks.after_success(
             hook_ctx: SDKHooks::AfterSuccessHookContext.new(
               hook_ctx: hook_ctx
@@ -2568,8 +2568,1188 @@ module StackOne
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            bytes: T.unsafe(obj)
+            body: T.unsafe(obj)
           )
+        elsif Utils.match_content_type(content_type, 'application/msword')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/octet-stream')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/pdf')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/rtf')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.ms-excel')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.ms-outlook')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.ms-powerpoint')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.oasis.opendocument.presentation')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.oasis.opendocument.spreadsheet')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.oasis.opendocument.text')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.openxmlformats-officedocument.presentationml.presentation')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/vnd.openxmlformats-officedocument.wordprocessingml.document')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/x-7z-compressed')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/x-rar-compressed')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/xml')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/zip')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'audio/mp4')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'audio/mpeg')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'audio/wav')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/bmp')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/gif')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/heic')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/jpeg')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/png')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/tiff')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'image/webp')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'message/rfc822')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'text/csv')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'text/html')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'text/rtf')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'video/avi')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'video/mp4')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'video/quicktime')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'video/webm')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            body: T.unsafe(obj)
+          )
+        elsif Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::DownloadApiModel)
+          response = Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            download_api_model: T.unsafe(obj)
+          )
+
+          return response
+        elsif Utils.match_content_type(content_type, 'text/plain')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          obj = http_response.env.body
+
+          return Models::Operations::AtsDownloadApplicationDocumentResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            download_api_model1: T.unsafe(obj)
+          )
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequestResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['401'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::UnauthorizedResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['403'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ForbiddenResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['404'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotFoundResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['408'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RequestTimedOutResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['409'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ConflictResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['412'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::PreconditionFailedResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['422'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::UnprocessableEntityResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['429'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::TooManyRequestsResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['500'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::InternalServerErrorResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['501'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotImplementedResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['502'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadGatewayResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
+    sig { params(request: Models::Operations::AtsGetApplicationRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationResponse) }
+    def get_application(request:, retries: nil, timeout_ms: nil)
+      # get_application - Get Application
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::AtsGetApplicationRequest,
+        base_url,
+        '/unified/ats/applications/{id}',
+        request
+      )
+      headers = Utils.get_headers(request)
+      headers = T.cast(headers, T::Hash[String, String])
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationRequest, request, nil)
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+      retries ||= @sdk_configuration.retry_config
+      retries ||= Utils::RetryConfig.new(
+        backoff: Utils::BackoffStrategy.new(
+          exponent: 1.5,
+          initial_interval: 500,
+          max_elapsed_time: 3_600_000,
+          max_interval: 60_000
+        ),
+        retry_connection_errors: true,
+        strategy: 'backoff'
+      )
+      retry_options = retries.to_faraday_retry_options(initial_time: Time.now)
+      retry_options[:retry_statuses] = [429, 408]
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client.dup
+      connection.request :retry, retry_options
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: [],
+        operation_id: 'ats_get_application',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          req.params = query_params
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ApplicationResult)
+          response = Models::Operations::AtsGetApplicationResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            application_result: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['400'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequestResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['401'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::UnauthorizedResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['403'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ForbiddenResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['404'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotFoundResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['408'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RequestTimedOutResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['409'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ConflictResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['412'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::PreconditionFailedResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['422'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::UnprocessableEntityResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['429'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::TooManyRequestsResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['500'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::InternalServerErrorResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['501'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotImplementedResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['502'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadGatewayResponse)
+          raise obj
+        else
+          raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown status code received'
+
+      end
+    end
+
+
+    sig { params(request: Models::Operations::AtsGetApplicationCustomFieldDefinitionRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationCustomFieldDefinitionResponse) }
+    def get_application_custom_field_definition(request:, retries: nil, timeout_ms: nil)
+      # get_application_custom_field_definition - Get Application Custom Field Definition
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = Utils.generate_url(
+        Models::Operations::AtsGetApplicationCustomFieldDefinitionRequest,
+        base_url,
+        '/unified/ats/custom_field_definitions/applications/{id}',
+        request
+      )
+      headers = Utils.get_headers(request)
+      headers = T.cast(headers, T::Hash[String, String])
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationCustomFieldDefinitionRequest, request, nil)
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+      retries ||= @sdk_configuration.retry_config
+      retries ||= Utils::RetryConfig.new(
+        backoff: Utils::BackoffStrategy.new(
+          exponent: 1.5,
+          initial_interval: 500,
+          max_elapsed_time: 3_600_000,
+          max_interval: 60_000
+        ),
+        retry_connection_errors: true,
+        strategy: 'backoff'
+      )
+      retry_options = retries.to_faraday_retry_options(initial_time: Time.now)
+      retry_options[:retry_statuses] = [429, 408]
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client.dup
+      connection.request :retry, retry_options
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: [],
+        operation_id: 'ats_get_application_custom_field_definition',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).get(url) do |req|
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          req.params = query_params
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['200'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionResultApiModel)
+          response = Models::Operations::AtsGetApplicationCustomFieldDefinitionResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            headers: {},
+            custom_field_definition_result_api_model: T.unsafe(obj)
+          )
+
+          return response
         else
           raise ::StackOne::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
         end
@@ -2752,20 +3932,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationResponse) }
-    def get_application(request:, retries: nil, timeout_ms: nil)
-      # get_application - Get Application
+    sig { params(request: Models::Operations::AtsGetApplicationDocumentRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationDocumentResponse) }
+    def get_application_document(request:, retries: nil, timeout_ms: nil)
+      # get_application_document - Get Application Document
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationRequest,
+        Models::Operations::AtsGetApplicationDocumentRequest,
         base_url,
-        '/unified/ats/applications/{id}',
+        '/unified/ats/applications/{id}/documents/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationDocumentRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -2795,7 +3975,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application',
+        operation_id: 'ats_get_application_document',
         security_source: @sdk_configuration.security_source
       )
 
@@ -2853,13 +4033,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ApplicationResult)
-          response = Models::Operations::AtsGetApplicationResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AtsDocumentResult)
+          response = Models::Operations::AtsGetApplicationDocumentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            application_result: T.unsafe(obj)
+            ats_document_result: T.unsafe(obj)
           )
 
           return response
@@ -3045,20 +4225,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationCustomFieldDefinitionRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationCustomFieldDefinitionResponse) }
-    def get_application_custom_field_definition(request:, retries: nil, timeout_ms: nil)
-      # get_application_custom_field_definition - Get Application Custom Field Definition
+    sig { params(request: Models::Operations::AtsGetApplicationDocumentCategoryRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationDocumentCategoryResponse) }
+    def get_application_document_category(request:, retries: nil, timeout_ms: nil)
+      # get_application_document_category - Get Application Document Category
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationCustomFieldDefinitionRequest,
+        Models::Operations::AtsGetApplicationDocumentCategoryRequest,
         base_url,
-        '/unified/ats/custom_field_definitions/applications/{id}',
+        '/unified/ats/documents/application_categories/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationCustomFieldDefinitionRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationDocumentCategoryRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3088,7 +4268,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_custom_field_definition',
+        operation_id: 'ats_get_application_document_category',
         security_source: @sdk_configuration.security_source
       )
 
@@ -3146,13 +4326,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionResultApiModel)
-          response = Models::Operations::AtsGetApplicationCustomFieldDefinitionResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ReferenceResult)
+          response = Models::Operations::AtsGetApplicationDocumentCategoryResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            custom_field_definition_result_api_model: T.unsafe(obj)
+            reference_result: T.unsafe(obj)
           )
 
           return response
@@ -3338,20 +4518,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationDocumentRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationDocumentResponse) }
-    def get_application_document(request:, retries: nil, timeout_ms: nil)
-      # get_application_document - Get Application Document
+    sig { params(request: Models::Operations::AtsGetApplicationNoteRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationNoteResponse) }
+    def get_application_note(request:, retries: nil, timeout_ms: nil)
+      # get_application_note - Get Application Note
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationDocumentRequest,
+        Models::Operations::AtsGetApplicationNoteRequest,
         base_url,
-        '/unified/ats/applications/{id}/documents/{subResourceId}',
+        '/unified/ats/applications/{id}/notes/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationDocumentRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationNoteRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3381,7 +4561,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_document',
+        operation_id: 'ats_get_application_note',
         security_source: @sdk_configuration.security_source
       )
 
@@ -3439,13 +4619,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AtsDocumentResult)
-          response = Models::Operations::AtsGetApplicationDocumentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::NoteResult)
+          response = Models::Operations::AtsGetApplicationNoteResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            ats_document_result: T.unsafe(obj)
+            note_result: T.unsafe(obj)
           )
 
           return response
@@ -3631,20 +4811,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationDocumentCategoryRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationDocumentCategoryResponse) }
-    def get_application_document_category(request:, retries: nil, timeout_ms: nil)
-      # get_application_document_category - Get Application Document Category
+    sig { params(request: Models::Operations::AtsGetApplicationOfferRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationOfferResponse) }
+    def get_application_offer(request:, retries: nil, timeout_ms: nil)
+      # get_application_offer - Get Application Offer
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationDocumentCategoryRequest,
+        Models::Operations::AtsGetApplicationOfferRequest,
         base_url,
-        '/unified/ats/documents/application_categories/{id}',
+        '/unified/ats/applications/{id}/offers/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationDocumentCategoryRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationOfferRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3674,7 +4854,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_document_category',
+        operation_id: 'ats_get_application_offer',
         security_source: @sdk_configuration.security_source
       )
 
@@ -3732,13 +4912,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ReferenceResult)
-          response = Models::Operations::AtsGetApplicationDocumentCategoryResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::OffersResult)
+          response = Models::Operations::AtsGetApplicationOfferResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            reference_result: T.unsafe(obj)
+            offers_result: T.unsafe(obj)
           )
 
           return response
@@ -3924,20 +5104,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationNoteRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationNoteResponse) }
-    def get_application_note(request:, retries: nil, timeout_ms: nil)
-      # get_application_note - Get Application Note
+    sig { params(request: Models::Operations::AtsGetApplicationScheduledInterviewRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationScheduledInterviewResponse) }
+    def get_application_scheduled_interview(request:, retries: nil, timeout_ms: nil)
+      # get_application_scheduled_interview - Get Applications scheduled interview
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationNoteRequest,
+        Models::Operations::AtsGetApplicationScheduledInterviewRequest,
         base_url,
-        '/unified/ats/applications/{id}/notes/{subResourceId}',
+        '/unified/ats/applications/{id}/scheduled_interviews/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationNoteRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationScheduledInterviewRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -3967,7 +5147,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_note',
+        operation_id: 'ats_get_application_scheduled_interview',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4025,13 +5205,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::NoteResult)
-          response = Models::Operations::AtsGetApplicationNoteResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ScheduledInterviewsResult)
+          response = Models::Operations::AtsGetApplicationScheduledInterviewResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            note_result: T.unsafe(obj)
+            scheduled_interviews_result: T.unsafe(obj)
           )
 
           return response
@@ -4217,20 +5397,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationOfferRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationOfferResponse) }
-    def get_application_offer(request:, retries: nil, timeout_ms: nil)
-      # get_application_offer - Get Application Offer
+    sig { params(request: Models::Operations::AtsGetApplicationScorecardRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationScorecardResponse) }
+    def get_application_scorecard(request:, retries: nil, timeout_ms: nil)
+      # get_application_scorecard - Get Application Scorecard
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationOfferRequest,
+        Models::Operations::AtsGetApplicationScorecardRequest,
         base_url,
-        '/unified/ats/applications/{id}/offers/{subResourceId}',
+        '/unified/ats/applications/{id}/scorecards/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationOfferRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationScorecardRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4260,7 +5440,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_offer',
+        operation_id: 'ats_get_application_scorecard',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4318,13 +5498,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::OffersResult)
-          response = Models::Operations::AtsGetApplicationOfferResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ScorecardsResult)
+          response = Models::Operations::AtsGetApplicationScorecardResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            offers_result: T.unsafe(obj)
+            scorecards_result: T.unsafe(obj)
           )
 
           return response
@@ -4510,20 +5690,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationScheduledInterviewRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationScheduledInterviewResponse) }
-    def get_application_scheduled_interview(request:, retries: nil, timeout_ms: nil)
-      # get_application_scheduled_interview - Get Applications scheduled interview
+    sig { params(request: Models::Operations::AtsGetApplicationStageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationStageResponse) }
+    def get_application_stage(request:, retries: nil, timeout_ms: nil)
+      # get_application_stage - Get Application Stage
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationScheduledInterviewRequest,
+        Models::Operations::AtsGetApplicationStageRequest,
         base_url,
-        '/unified/ats/applications/{id}/scheduled_interviews/{subResourceId}',
+        '/unified/ats/application_stages/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationScheduledInterviewRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationStageRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4553,7 +5733,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_scheduled_interview',
+        operation_id: 'ats_get_application_stage',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4611,13 +5791,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ScheduledInterviewsResult)
-          response = Models::Operations::AtsGetApplicationScheduledInterviewResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::InterviewStageResult)
+          response = Models::Operations::AtsGetApplicationStageResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            scheduled_interviews_result: T.unsafe(obj)
+            interview_stage_result: T.unsafe(obj)
           )
 
           return response
@@ -4803,20 +5983,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetApplicationScorecardRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetApplicationScorecardResponse) }
-    def get_application_scorecard(request:, retries: nil, timeout_ms: nil)
-      # get_application_scorecard - Get Application Scorecard
+    sig { params(request: Models::Operations::AtsGetAssessmentsPackageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetAssessmentsPackageResponse) }
+    def get_assessments_package(request:, retries: nil, timeout_ms: nil)
+      # get_assessments_package - Get Assessments Package
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetApplicationScorecardRequest,
+        Models::Operations::AtsGetAssessmentsPackageRequest,
         base_url,
-        '/unified/ats/applications/{id}/scorecards/{subResourceId}',
+        '/unified/ats/assessments/packages/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetApplicationScorecardRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetAssessmentsPackageRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -4846,7 +6026,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_application_scorecard',
+        operation_id: 'ats_get_assessments_package',
         security_source: @sdk_configuration.security_source
       )
 
@@ -4904,13 +6084,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ScorecardsResult)
-          response = Models::Operations::AtsGetApplicationScorecardResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AssessmentPackageResult)
+          response = Models::Operations::AtsGetAssessmentsPackageResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            scorecards_result: T.unsafe(obj)
+            assessment_package_result: T.unsafe(obj)
           )
 
           return response
@@ -5096,20 +6276,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetAssessmentsPackageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetAssessmentsPackageResponse) }
-    def get_assessments_package(request:, retries: nil, timeout_ms: nil)
-      # get_assessments_package - Get Assessments Package
+    sig { params(request: Models::Operations::AtsGetBackgroundCheckPackageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetBackgroundCheckPackageResponse) }
+    def get_background_check_package(request:, retries: nil, timeout_ms: nil)
+      # get_background_check_package - Get Background Check Package
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetAssessmentsPackageRequest,
+        Models::Operations::AtsGetBackgroundCheckPackageRequest,
         base_url,
-        '/unified/ats/assessments/packages/{id}',
+        '/unified/ats/background_checks/packages/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetAssessmentsPackageRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetBackgroundCheckPackageRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5139,7 +6319,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_assessments_package',
+        operation_id: 'ats_get_background_check_package',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5197,13 +6377,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AssessmentPackageResult)
-          response = Models::Operations::AtsGetAssessmentsPackageResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::BackgroundCheckPackageResult)
+          response = Models::Operations::AtsGetBackgroundCheckPackageResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            assessment_package_result: T.unsafe(obj)
+            background_check_package_result: T.unsafe(obj)
           )
 
           return response
@@ -5389,20 +6569,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetBackgroundCheckPackageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetBackgroundCheckPackageResponse) }
-    def get_background_check_package(request:, retries: nil, timeout_ms: nil)
-      # get_background_check_package - Get Background Check Package
+    sig { params(request: Models::Operations::AtsGetCandidateRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetCandidateResponse) }
+    def get_candidate(request:, retries: nil, timeout_ms: nil)
+      # get_candidate - Get Candidate
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetBackgroundCheckPackageRequest,
+        Models::Operations::AtsGetCandidateRequest,
         base_url,
-        '/unified/ats/background_checks/packages/{id}',
+        '/unified/ats/candidates/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetBackgroundCheckPackageRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetCandidateRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5432,7 +6612,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_background_check_package',
+        operation_id: 'ats_get_candidate',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5490,13 +6670,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::BackgroundCheckPackageResult)
-          response = Models::Operations::AtsGetBackgroundCheckPackageResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CandidateResult)
+          response = Models::Operations::AtsGetCandidateResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            background_check_package_result: T.unsafe(obj)
+            candidate_result: T.unsafe(obj)
           )
 
           return response
@@ -5682,20 +6862,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetCandidateRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetCandidateResponse) }
-    def get_candidate(request:, retries: nil, timeout_ms: nil)
-      # get_candidate - Get Candidate
+    sig { params(request: Models::Operations::AtsGetCandidateCustomFieldDefinitionRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetCandidateCustomFieldDefinitionResponse) }
+    def get_candidate_custom_field_definition(request:, retries: nil, timeout_ms: nil)
+      # get_candidate_custom_field_definition - Get Candidate Custom Field Definition
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetCandidateRequest,
+        Models::Operations::AtsGetCandidateCustomFieldDefinitionRequest,
         base_url,
-        '/unified/ats/candidates/{id}',
+        '/unified/ats/custom_field_definitions/candidates/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetCandidateRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetCandidateCustomFieldDefinitionRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -5725,7 +6905,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_candidate',
+        operation_id: 'ats_get_candidate_custom_field_definition',
         security_source: @sdk_configuration.security_source
       )
 
@@ -5783,13 +6963,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CandidateResult)
-          response = Models::Operations::AtsGetCandidateResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionResultApiModel)
+          response = Models::Operations::AtsGetCandidateCustomFieldDefinitionResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            candidate_result: T.unsafe(obj)
+            custom_field_definition_result_api_model: T.unsafe(obj)
           )
 
           return response
@@ -5975,20 +7155,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetCandidateCustomFieldDefinitionRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetCandidateCustomFieldDefinitionResponse) }
-    def get_candidate_custom_field_definition(request:, retries: nil, timeout_ms: nil)
-      # get_candidate_custom_field_definition - Get Candidate Custom Field Definition
+    sig { params(request: Models::Operations::AtsGetCandidateNoteRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetCandidateNoteResponse) }
+    def get_candidate_note(request:, retries: nil, timeout_ms: nil)
+      # get_candidate_note - Get Candidate Note
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetCandidateCustomFieldDefinitionRequest,
+        Models::Operations::AtsGetCandidateNoteRequest,
         base_url,
-        '/unified/ats/custom_field_definitions/candidates/{id}',
+        '/unified/ats/candidates/{id}/notes/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetCandidateCustomFieldDefinitionRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetCandidateNoteRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6018,7 +7198,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_candidate_custom_field_definition',
+        operation_id: 'ats_get_candidate_note',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6076,13 +7256,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionResultApiModel)
-          response = Models::Operations::AtsGetCandidateCustomFieldDefinitionResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::NoteResult)
+          response = Models::Operations::AtsGetCandidateNoteResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            custom_field_definition_result_api_model: T.unsafe(obj)
+            note_result: T.unsafe(obj)
           )
 
           return response
@@ -6268,20 +7448,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetCandidateNoteRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetCandidateNoteResponse) }
-    def get_candidate_note(request:, retries: nil, timeout_ms: nil)
-      # get_candidate_note - Get Candidate Note
+    sig { params(request: Models::Operations::AtsGetDepartmentRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetDepartmentResponse) }
+    def get_department(request:, retries: nil, timeout_ms: nil)
+      # get_department - Get Department
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetCandidateNoteRequest,
+        Models::Operations::AtsGetDepartmentRequest,
         base_url,
-        '/unified/ats/candidates/{id}/notes/{subResourceId}',
+        '/unified/ats/departments/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetCandidateNoteRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetDepartmentRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6311,7 +7491,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_candidate_note',
+        operation_id: 'ats_get_department',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6369,13 +7549,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::NoteResult)
-          response = Models::Operations::AtsGetCandidateNoteResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::DepartmentResult)
+          response = Models::Operations::AtsGetDepartmentResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            note_result: T.unsafe(obj)
+            department_result: T.unsafe(obj)
           )
 
           return response
@@ -6561,20 +7741,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetDepartmentRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetDepartmentResponse) }
-    def get_department(request:, retries: nil, timeout_ms: nil)
-      # get_department - Get Department
+    sig { params(request: Models::Operations::AtsGetInterviewRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetInterviewResponse) }
+    def get_interview(request:, retries: nil, timeout_ms: nil)
+      # get_interview - Get Interview
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetDepartmentRequest,
+        Models::Operations::AtsGetInterviewRequest,
         base_url,
-        '/unified/ats/departments/{id}',
+        '/unified/ats/interviews/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetDepartmentRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetInterviewRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6604,7 +7784,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_department',
+        operation_id: 'ats_get_interview',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6662,13 +7842,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::DepartmentResult)
-          response = Models::Operations::AtsGetDepartmentResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::InterviewsResult)
+          response = Models::Operations::AtsGetInterviewResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            department_result: T.unsafe(obj)
+            interviews_result: T.unsafe(obj)
           )
 
           return response
@@ -6854,20 +8034,22 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetInterviewRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetInterviewResponse) }
-    def get_interview(request:, retries: nil, timeout_ms: nil)
-      # get_interview - Get Interview
+    sig { params(request: Models::Operations::AtsGetInterviewStageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetInterviewStageResponse) }
+    def get_interview_stage(request:, retries: nil, timeout_ms: nil)
+      # get_interview_stage - Get Interview Stage
+      # 
+      # @deprecated  method: This will be removed in a future release, please migrate away from it as soon as possible.
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetInterviewRequest,
+        Models::Operations::AtsGetInterviewStageRequest,
         base_url,
-        '/unified/ats/interviews/{id}',
+        '/unified/ats/interview_stages/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetInterviewRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetInterviewStageRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -6897,7 +8079,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_interview',
+        operation_id: 'ats_get_interview_stage',
         security_source: @sdk_configuration.security_source
       )
 
@@ -6955,13 +8137,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::InterviewsResult)
-          response = Models::Operations::AtsGetInterviewResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::InterviewStageResult)
+          response = Models::Operations::AtsGetInterviewStageResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            interviews_result: T.unsafe(obj)
+            interview_stage_result: T.unsafe(obj)
           )
 
           return response
@@ -7147,20 +8329,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetInterviewStageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetInterviewStageResponse) }
-    def get_interview_stage(request:, retries: nil, timeout_ms: nil)
-      # get_interview_stage - Get Interview Stage
+    sig { params(request: Models::Operations::AtsGetJobRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobResponse) }
+    def get_job(request:, retries: nil, timeout_ms: nil)
+      # get_job - Get Job
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetInterviewStageRequest,
+        Models::Operations::AtsGetJobRequest,
         base_url,
-        '/unified/ats/interview_stages/{id}',
+        '/unified/ats/jobs/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetInterviewStageRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetJobRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -7190,7 +8372,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_interview_stage',
+        operation_id: 'ats_get_job',
         security_source: @sdk_configuration.security_source
       )
 
@@ -7248,13 +8430,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::InterviewStageResult)
-          response = Models::Operations::AtsGetInterviewStageResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AtsJobResult)
+          response = Models::Operations::AtsGetJobResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            interview_stage_result: T.unsafe(obj)
+            ats_job_result: T.unsafe(obj)
           )
 
           return response
@@ -7440,20 +8622,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetJobRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobResponse) }
-    def get_job(request:, retries: nil, timeout_ms: nil)
-      # get_job - Get Job
+    sig { params(request: Models::Operations::AtsGetJobApplicationStageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobApplicationStageResponse) }
+    def get_job_application_stage(request:, retries: nil, timeout_ms: nil)
+      # get_job_application_stage - Get Job Application Stage
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetJobRequest,
+        Models::Operations::AtsGetJobApplicationStageRequest,
         base_url,
-        '/unified/ats/jobs/{id}',
+        '/unified/ats/jobs/{id}/application_stages/{subResourceId}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetJobRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetJobApplicationStageRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -7483,7 +8665,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_job',
+        operation_id: 'ats_get_job_application_stage',
         security_source: @sdk_configuration.security_source
       )
 
@@ -7541,13 +8723,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AtsJobResult)
-          response = Models::Operations::AtsGetJobResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ApplicationStageResult)
+          response = Models::Operations::AtsGetJobApplicationStageResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            ats_job_result: T.unsafe(obj)
+            application_stage_result: T.unsafe(obj)
           )
 
           return response
@@ -7733,20 +8915,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetJobApplicationStageRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobApplicationStageResponse) }
-    def get_job_application_stage(request:, retries: nil, timeout_ms: nil)
-      # get_job_application_stage - Get Job Application Stage
+    sig { params(request: Models::Operations::AtsGetJobCustomFieldDefinitionRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobCustomFieldDefinitionResponse) }
+    def get_job_custom_field_definition(request:, retries: nil, timeout_ms: nil)
+      # get_job_custom_field_definition - Get Job Custom Field Definition
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetJobApplicationStageRequest,
+        Models::Operations::AtsGetJobCustomFieldDefinitionRequest,
         base_url,
-        '/unified/ats/jobs/{id}/application_stages/{subResourceId}',
+        '/unified/ats/custom_field_definitions/jobs/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetJobApplicationStageRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetJobCustomFieldDefinitionRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -7776,7 +8958,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_job_application_stage',
+        operation_id: 'ats_get_job_custom_field_definition',
         security_source: @sdk_configuration.security_source
       )
 
@@ -7834,13 +9016,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ApplicationStageResult)
-          response = Models::Operations::AtsGetJobApplicationStageResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionResultApiModel)
+          response = Models::Operations::AtsGetJobCustomFieldDefinitionResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            application_stage_result: T.unsafe(obj)
+            custom_field_definition_result_api_model: T.unsafe(obj)
           )
 
           return response
@@ -8026,20 +9208,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetJobCustomFieldDefinitionRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobCustomFieldDefinitionResponse) }
-    def get_job_custom_field_definition(request:, retries: nil, timeout_ms: nil)
-      # get_job_custom_field_definition - Get Job Custom Field Definition
+    sig { params(request: Models::Operations::AtsGetJobPostingRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobPostingResponse) }
+    def get_job_posting(request:, retries: nil, timeout_ms: nil)
+      # get_job_posting - Get Job Posting
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetJobCustomFieldDefinitionRequest,
+        Models::Operations::AtsGetJobPostingRequest,
         base_url,
-        '/unified/ats/custom_field_definitions/jobs/{id}',
+        '/unified/ats/job_postings/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetJobCustomFieldDefinitionRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetJobPostingRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -8069,7 +9251,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_job_custom_field_definition',
+        operation_id: 'ats_get_job_posting',
         security_source: @sdk_configuration.security_source
       )
 
@@ -8127,13 +9309,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionResultApiModel)
-          response = Models::Operations::AtsGetJobCustomFieldDefinitionResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::JobPostingResult)
+          response = Models::Operations::AtsGetJobPostingResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            custom_field_definition_result_api_model: T.unsafe(obj)
+            job_posting_result: T.unsafe(obj)
           )
 
           return response
@@ -8319,20 +9501,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetJobPostingRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetJobPostingResponse) }
-    def get_job_posting(request:, retries: nil, timeout_ms: nil)
-      # get_job_posting - Get Job Posting
+    sig { params(request: Models::Operations::AtsGetListRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetListResponse) }
+    def get_list(request:, retries: nil, timeout_ms: nil)
+      # get_list - Get List
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetJobPostingRequest,
+        Models::Operations::AtsGetListRequest,
         base_url,
-        '/unified/ats/job_postings/{id}',
+        '/unified/ats/lists/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetJobPostingRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetListRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -8362,7 +9544,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_job_posting',
+        operation_id: 'ats_get_list',
         security_source: @sdk_configuration.security_source
       )
 
@@ -8420,13 +9602,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::JobPostingResult)
-          response = Models::Operations::AtsGetJobPostingResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ListResult)
+          response = Models::Operations::AtsGetListResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            job_posting_result: T.unsafe(obj)
+            list_result: T.unsafe(obj)
           )
 
           return response
@@ -8612,20 +9794,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetListRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetListResponse) }
-    def get_list(request:, retries: nil, timeout_ms: nil)
-      # get_list - Get List
+    sig { params(request: Models::Operations::AtsGetLocationRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetLocationResponse) }
+    def get_location(request:, retries: nil, timeout_ms: nil)
+      # get_location - Get Location
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetListRequest,
+        Models::Operations::AtsGetLocationRequest,
         base_url,
-        '/unified/ats/lists/{id}',
+        '/unified/ats/locations/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetListRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetLocationRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -8655,7 +9837,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_list',
+        operation_id: 'ats_get_location',
         security_source: @sdk_configuration.security_source
       )
 
@@ -8713,13 +9895,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ListResult)
-          response = Models::Operations::AtsGetListResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ATSLocationResult)
+          response = Models::Operations::AtsGetLocationResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            list_result: T.unsafe(obj)
+            ats_location_result: T.unsafe(obj)
           )
 
           return response
@@ -8905,20 +10087,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetLocationRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetLocationResponse) }
-    def get_location(request:, retries: nil, timeout_ms: nil)
-      # get_location - Get Location
+    sig { params(request: Models::Operations::AtsGetOfferRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetOfferResponse) }
+    def get_offer(request:, retries: nil, timeout_ms: nil)
+      # get_offer - Get Offer
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetLocationRequest,
+        Models::Operations::AtsGetOfferRequest,
         base_url,
-        '/unified/ats/locations/{id}',
+        '/unified/ats/offers/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetLocationRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetOfferRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -8948,7 +10130,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_location',
+        operation_id: 'ats_get_offer',
         security_source: @sdk_configuration.security_source
       )
 
@@ -9006,13 +10188,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ATSLocationResult)
-          response = Models::Operations::AtsGetLocationResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::OffersResult)
+          response = Models::Operations::AtsGetOfferResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            ats_location_result: T.unsafe(obj)
+            offers_result: T.unsafe(obj)
           )
 
           return response
@@ -9198,20 +10380,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetOfferRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetOfferResponse) }
-    def get_offer(request:, retries: nil, timeout_ms: nil)
-      # get_offer - Get Offer
+    sig { params(request: Models::Operations::AtsGetRejectedReasonRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetRejectedReasonResponse) }
+    def get_rejected_reason(request:, retries: nil, timeout_ms: nil)
+      # get_rejected_reason - Get Rejected Reason
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetOfferRequest,
+        Models::Operations::AtsGetRejectedReasonRequest,
         base_url,
-        '/unified/ats/offers/{id}',
+        '/unified/ats/rejected_reasons/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetOfferRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetRejectedReasonRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -9241,7 +10423,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_offer',
+        operation_id: 'ats_get_rejected_reason',
         security_source: @sdk_configuration.security_source
       )
 
@@ -9299,13 +10481,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::OffersResult)
-          response = Models::Operations::AtsGetOfferResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::RejectedReasonResult)
+          response = Models::Operations::AtsGetRejectedReasonResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            offers_result: T.unsafe(obj)
+            rejected_reason_result: T.unsafe(obj)
           )
 
           return response
@@ -9491,20 +10673,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetRejectedReasonRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetRejectedReasonResponse) }
-    def get_rejected_reason(request:, retries: nil, timeout_ms: nil)
-      # get_rejected_reason - Get Rejected Reason
+    sig { params(request: Models::Operations::AtsGetUserRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetUserResponse) }
+    def get_user(request:, retries: nil, timeout_ms: nil)
+      # get_user - Get User
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetRejectedReasonRequest,
+        Models::Operations::AtsGetUserRequest,
         base_url,
-        '/unified/ats/rejected_reasons/{id}',
+        '/unified/ats/users/{id}',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetRejectedReasonRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsGetUserRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -9534,7 +10716,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_rejected_reason',
+        operation_id: 'ats_get_user',
         security_source: @sdk_configuration.security_source
       )
 
@@ -9592,13 +10774,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::RejectedReasonResult)
-          response = Models::Operations::AtsGetRejectedReasonResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::UserResult)
+          response = Models::Operations::AtsGetUserResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            rejected_reason_result: T.unsafe(obj)
+            user_result: T.unsafe(obj)
           )
 
           return response
@@ -9784,20 +10966,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsGetUserRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsGetUserResponse) }
-    def get_user(request:, retries: nil, timeout_ms: nil)
-      # get_user - Get User
+    sig { params(request: Models::Operations::AtsListApplicationChangesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationChangesResponse) }
+    def list_application_changes(request:, retries: nil, timeout_ms: nil)
+      # list_application_changes - List Application Changes
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsGetUserRequest,
+        Models::Operations::AtsListApplicationChangesRequest,
         base_url,
-        '/unified/ats/users/{id}',
+        '/unified/ats/applications/{id}/changes',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsGetUserRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationChangesRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -9827,7 +11009,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_get_user',
+        operation_id: 'ats_list_application_changes',
         security_source: @sdk_configuration.security_source
       )
 
@@ -9885,14 +11067,41 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::UserResult)
-          response = Models::Operations::AtsGetUserResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ApplicationChangesPaginated)
+          response = Models::Operations::AtsListApplicationChangesResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            user_result: T.unsafe(obj)
+            application_changes_paginated: T.unsafe(obj)
           )
+          sdk = self
+
+          response.next_page = proc do 
+            next_cursor = Janeway.enum_for('$.next', JSON.parse(response_data)).search
+            if next_cursor.nil?
+              next nil
+            else
+              next_cursor = next_cursor[0]
+              if next_cursor.nil?
+                next nil
+              end
+            end
+
+            sdk.list_application_changes(
+              request: Models::Operations::AtsListApplicationChangesRequest.new(
+                fields_: request.fields_,
+                filter: request.filter,
+                id: request.id,
+                next_: next_cursor,
+                page_size: request.page_size,
+                proxy: request.proxy,
+                raw: request.raw,
+                x_account_id: request.x_account_id
+              )
+            )
+          end
+
 
           return response
         else
@@ -10077,20 +11286,15 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsListApplicationChangesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationChangesResponse) }
-    def list_application_changes(request:, retries: nil, timeout_ms: nil)
-      # list_application_changes - List Application Changes
+    sig { params(request: Models::Operations::AtsListApplicationCustomFieldDefinitionsRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationCustomFieldDefinitionsResponse) }
+    def list_application_custom_field_definitions(request:, retries: nil, timeout_ms: nil)
+      # list_application_custom_field_definitions - List Application Custom Field Definitions
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::AtsListApplicationChangesRequest,
-        base_url,
-        '/unified/ats/applications/{id}/changes',
-        request
-      )
+      url = "#{base_url}/unified/ats/custom_field_definitions/applications"
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationChangesRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationCustomFieldDefinitionsRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -10120,7 +11324,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_list_application_changes',
+        operation_id: 'ats_list_application_custom_field_definitions',
         security_source: @sdk_configuration.security_source
       )
 
@@ -10178,13 +11382,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ApplicationChangesPaginated)
-          response = Models::Operations::AtsListApplicationChangesResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionsPaginated)
+          response = Models::Operations::AtsListApplicationCustomFieldDefinitionsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            application_changes_paginated: T.unsafe(obj)
+            custom_field_definitions_paginated: T.unsafe(obj)
           )
           sdk = self
 
@@ -10199,15 +11403,16 @@ module StackOne
               end
             end
 
-            sdk.list_application_changes(
-              request: Models::Operations::AtsListApplicationChangesRequest.new(
+            sdk.list_application_custom_field_definitions(
+              request: Models::Operations::AtsListApplicationCustomFieldDefinitionsRequest.new(
                 fields_: request.fields_,
                 filter: request.filter,
-                id: request.id,
                 next_: next_cursor,
+                page: request.page,
                 page_size: request.page_size,
                 proxy: request.proxy,
                 raw: request.raw,
+                updated_after: request.updated_after,
                 x_account_id: request.x_account_id
               )
             )
@@ -10397,15 +11602,15 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsListApplicationCustomFieldDefinitionsRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationCustomFieldDefinitionsResponse) }
-    def list_application_custom_field_definitions(request:, retries: nil, timeout_ms: nil)
-      # list_application_custom_field_definitions - List Application Custom Field Definitions
+    sig { params(request: Models::Operations::AtsListApplicationDocumentCategoriesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationDocumentCategoriesResponse) }
+    def list_application_document_categories(request:, retries: nil, timeout_ms: nil)
+      # list_application_document_categories - List Application Document Categories
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/ats/custom_field_definitions/applications"
+      url = "#{base_url}/unified/ats/documents/application_categories"
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationCustomFieldDefinitionsRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationDocumentCategoriesRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -10435,7 +11640,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_list_application_custom_field_definitions',
+        operation_id: 'ats_list_application_document_categories',
         security_source: @sdk_configuration.security_source
       )
 
@@ -10493,13 +11698,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::CustomFieldDefinitionsPaginated)
-          response = Models::Operations::AtsListApplicationCustomFieldDefinitionsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ReferencePaginated)
+          response = Models::Operations::AtsListApplicationDocumentCategoriesResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            custom_field_definitions_paginated: T.unsafe(obj)
+            reference_paginated: T.unsafe(obj)
           )
           sdk = self
 
@@ -10514,8 +11719,8 @@ module StackOne
               end
             end
 
-            sdk.list_application_custom_field_definitions(
-              request: Models::Operations::AtsListApplicationCustomFieldDefinitionsRequest.new(
+            sdk.list_application_document_categories(
+              request: Models::Operations::AtsListApplicationDocumentCategoriesRequest.new(
                 fields_: request.fields_,
                 filter: request.filter,
                 next_: next_cursor,
@@ -10713,15 +11918,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsListApplicationDocumentCategoriesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationDocumentCategoriesResponse) }
-    def list_application_document_categories(request:, retries: nil, timeout_ms: nil)
-      # list_application_document_categories - List Application Document Categories
+    sig { params(request: Models::Operations::AtsListApplicationDocumentsRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationDocumentsResponse) }
+    def list_application_documents(request:, retries: nil, timeout_ms: nil)
+      # list_application_documents - List Application Documents
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = "#{base_url}/unified/ats/documents/application_categories"
+      url = Utils.generate_url(
+        Models::Operations::AtsListApplicationDocumentsRequest,
+        base_url,
+        '/unified/ats/applications/{id}/documents',
+        request
+      )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationDocumentCategoriesRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationDocumentsRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -10751,7 +11961,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_list_application_document_categories',
+        operation_id: 'ats_list_application_documents',
         security_source: @sdk_configuration.security_source
       )
 
@@ -10809,13 +12019,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ReferencePaginated)
-          response = Models::Operations::AtsListApplicationDocumentCategoriesResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AtsDocumentsPaginated)
+          response = Models::Operations::AtsListApplicationDocumentsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            reference_paginated: T.unsafe(obj)
+            ats_documents_paginated: T.unsafe(obj)
           )
           sdk = self
 
@@ -10830,15 +12040,17 @@ module StackOne
               end
             end
 
-            sdk.list_application_document_categories(
-              request: Models::Operations::AtsListApplicationDocumentCategoriesRequest.new(
+            sdk.list_application_documents(
+              request: Models::Operations::AtsListApplicationDocumentsRequest.new(
                 fields_: request.fields_,
                 filter: request.filter,
+                id: request.id,
                 next_: next_cursor,
                 page: request.page,
                 page_size: request.page_size,
                 proxy: request.proxy,
                 raw: request.raw,
+                sync_token: request.sync_token,
                 updated_after: request.updated_after,
                 x_account_id: request.x_account_id
               )
@@ -11029,20 +12241,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsListApplicationDocumentsRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationDocumentsResponse) }
-    def list_application_documents(request:, retries: nil, timeout_ms: nil)
-      # list_application_documents - List Application Documents
+    sig { params(request: Models::Operations::AtsListApplicationNotesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationNotesResponse) }
+    def list_application_notes(request:, retries: nil, timeout_ms: nil)
+      # list_application_notes - List Application Notes
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsListApplicationDocumentsRequest,
+        Models::Operations::AtsListApplicationNotesRequest,
         base_url,
-        '/unified/ats/applications/{id}/documents',
+        '/unified/ats/applications/{id}/notes',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationDocumentsRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationNotesRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -11072,7 +12284,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_list_application_documents',
+        operation_id: 'ats_list_application_notes',
         security_source: @sdk_configuration.security_source
       )
 
@@ -11130,13 +12342,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AtsDocumentsPaginated)
-          response = Models::Operations::AtsListApplicationDocumentsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::NotesPaginated)
+          response = Models::Operations::AtsListApplicationNotesResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            ats_documents_paginated: T.unsafe(obj)
+            notes_paginated: T.unsafe(obj)
           )
           sdk = self
 
@@ -11151,8 +12363,8 @@ module StackOne
               end
             end
 
-            sdk.list_application_documents(
-              request: Models::Operations::AtsListApplicationDocumentsRequest.new(
+            sdk.list_application_notes(
+              request: Models::Operations::AtsListApplicationNotesRequest.new(
                 fields_: request.fields_,
                 filter: request.filter,
                 id: request.id,
@@ -11352,20 +12564,20 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsListApplicationNotesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationNotesResponse) }
-    def list_application_notes(request:, retries: nil, timeout_ms: nil)
-      # list_application_notes - List Application Notes
+    sig { params(request: Models::Operations::AtsListApplicationScorecardsRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationScorecardsResponse) }
+    def list_application_scorecards(request:, retries: nil, timeout_ms: nil)
+      # list_application_scorecards - List Application Scorecards
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = Utils.generate_url(
-        Models::Operations::AtsListApplicationNotesRequest,
+        Models::Operations::AtsListApplicationScorecardsRequest,
         base_url,
-        '/unified/ats/applications/{id}/notes',
+        '/unified/ats/applications/{id}/scorecards',
         request
       )
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationNotesRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationScorecardsRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -11395,7 +12607,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_list_application_notes',
+        operation_id: 'ats_list_application_scorecards',
         security_source: @sdk_configuration.security_source
       )
 
@@ -11453,13 +12665,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::NotesPaginated)
-          response = Models::Operations::AtsListApplicationNotesResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ScorecardsPaginated)
+          response = Models::Operations::AtsListApplicationScorecardsResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            notes_paginated: T.unsafe(obj)
+            scorecards_paginated: T.unsafe(obj)
           )
           sdk = self
 
@@ -11474,8 +12686,8 @@ module StackOne
               end
             end
 
-            sdk.list_application_notes(
-              request: Models::Operations::AtsListApplicationNotesRequest.new(
+            sdk.list_application_scorecards(
+              request: Models::Operations::AtsListApplicationScorecardsRequest.new(
                 fields_: request.fields_,
                 filter: request.filter,
                 id: request.id,
@@ -11675,20 +12887,15 @@ module StackOne
     end
 
 
-    sig { params(request: Models::Operations::AtsListApplicationScorecardsRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationScorecardsResponse) }
-    def list_application_scorecards(request:, retries: nil, timeout_ms: nil)
-      # list_application_scorecards - List Application Scorecards
+    sig { params(request: Models::Operations::AtsListApplicationStagesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListApplicationStagesResponse) }
+    def list_application_stages(request:, retries: nil, timeout_ms: nil)
+      # list_application_stages - List Application Stages
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
-      url = Utils.generate_url(
-        Models::Operations::AtsListApplicationScorecardsRequest,
-        base_url,
-        '/unified/ats/applications/{id}/scorecards',
-        request
-      )
+      url = "#{base_url}/unified/ats/application_stages"
       headers = Utils.get_headers(request)
       headers = T.cast(headers, T::Hash[String, String])
-      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationScorecardsRequest, request, nil)
+      query_params = Utils.get_query_params(Models::Operations::AtsListApplicationStagesRequest, request, nil)
       headers['Accept'] = 'application/json'
       headers['user-agent'] = @sdk_configuration.user_agent
       retries ||= @sdk_configuration.retry_config
@@ -11718,7 +12925,7 @@ module StackOne
         config: @sdk_configuration,
         base_url: base_url,
         oauth2_scopes: [],
-        operation_id: 'ats_list_application_scorecards',
+        operation_id: 'ats_list_application_stages',
         security_source: @sdk_configuration.security_source
       )
 
@@ -11776,13 +12983,13 @@ module StackOne
             response: http_response
           )
           response_data = http_response.env.response_body
-          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::ScorecardsPaginated)
-          response = Models::Operations::AtsListApplicationScorecardsResponse.new(
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::InterviewStagesPaginated)
+          response = Models::Operations::AtsListApplicationStagesResponse.new(
             status_code: http_response.status,
             content_type: content_type,
             raw_response: http_response,
             headers: {},
-            scorecards_paginated: T.unsafe(obj)
+            interview_stages_paginated: T.unsafe(obj)
           )
           sdk = self
 
@@ -11797,11 +13004,10 @@ module StackOne
               end
             end
 
-            sdk.list_application_scorecards(
-              request: Models::Operations::AtsListApplicationScorecardsRequest.new(
+            sdk.list_application_stages(
+              request: Models::Operations::AtsListApplicationStagesRequest.new(
                 fields_: request.fields_,
                 filter: request.filter,
-                id: request.id,
                 next_: next_cursor,
                 page: request.page,
                 page_size: request.page_size,
@@ -14873,6 +16079,8 @@ module StackOne
     sig { params(request: Models::Operations::AtsListInterviewStagesRequest, retries: T.nilable(Utils::RetryConfig), timeout_ms: T.nilable(Integer)).returns(Models::Operations::AtsListInterviewStagesResponse) }
     def list_interview_stages(request:, retries: nil, timeout_ms: nil)
       # list_interview_stages - List Interview Stages
+      # 
+      # @deprecated  method: This will be removed in a future release, please migrate away from it as soon as possible.
       url, params = @sdk_configuration.get_server_details
       base_url = Utils.template_url(url, params)
       url = "#{base_url}/unified/ats/interview_stages"